From 20285af5c1ab0af7e29c868ba4ae46b72e38f754 Mon Sep 17 00:00:00 2001
From: Brian O'Kelley <bokelley@scope3.com>
Date: Wed, 19 Aug 2026 14:09:05 +0200
Subject: [PATCH] feat(sdk): add version-pinned server and model surfaces

---
 .pre-commit-config.yaml                 |     9 +-
 Makefile                                |     2 +
 pyproject.toml                          |     6 +-
 scripts/generate_versioned_stubs.py     |   571 +
 src/adcp/decisioning/__init__.py        |     4 +-
 src/adcp/decisioning/handler.py         |    10 +
 src/adcp/decisioning/serve.py           |    15 +
 src/adcp/migrate/v3_to_v4.py            |   113 +-
 src/adcp/server/a2a_server.py           |    15 +-
 src/adcp/server/serve.py                |   104 +-
 src/adcp/testing/decisioning.py         |    64 +-
 src/adcp/types/__init__.py              |    29 +
 src/adcp/types/_eager.py                |    28 +
 src/adcp/types/aliases.py               |    49 +
 src/adcp/types/v30.py                   |     2 +-
 src/adcp/types/v30.pyi                  | 10672 ++++++
 src/adcp/types/v31.py                   |     2 +-
 src/adcp/types/v31.pyi                  | 41465 ++++++++++++++++++++++
 src/adcp/types/v32.py                   |     2 +-
 src/adcp/types/v32.pyi                  | 31964 +++++++++++++++++
 src/adcp/types/versioned.py             |    84 +-
 tests/fixtures/public_api_snapshot.json |    14 +
 tests/test_a2a_server.py                |    26 +
 tests/test_collision_aliases.py         |    23 +
 tests/test_decisioning_serve.py         |    47 +
 tests/test_migrate_v3_to_v4.py          |    55 +-
 tests/test_testing_decisioning.py       |    94 +-
 tests/test_version_scoped_models.py     |    46 +
 tests/type_checks/versioned_types.py    |   118 +
 29 files changed, 85555 insertions(+), 78 deletions(-)
 create mode 100644 scripts/generate_versioned_stubs.py
 create mode 100644 src/adcp/types/v30.pyi
 create mode 100644 src/adcp/types/v31.pyi
 create mode 100644 src/adcp/types/v32.pyi
 create mode 100644 tests/type_checks/versioned_types.py

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index a3867c497..d53bfded2 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -10,7 +10,9 @@ repos:
       - id: black
         language_version: python3.11
         args: [--line-length=100]
-        exclude: ^src/adcp/types/generated_poc/
+        # Version-scoped stubs are deterministically emitted and checked by
+        # make validate-generated; reformatting them makes the checked output stale.
+        exclude: ^(src/adcp/types/generated_poc/|src/adcp/types/v(30|31|32)\.pyi$)
 
   # Ruff linting (ignoring line-length for now - black handles it)
   - repo: https://github.com/astral-sh/ruff-pre-commit
@@ -75,8 +77,9 @@ repos:
         # schemas (e.g. v3.1+ bundled core/*-response.json files exceed
         # 6 MB). They're canonical from the protocol release tarball, not
         # hand-authored — the large-file gate would block every schema
-        # sync. Same exclusion as the file-fixer hooks above.
-        exclude: ^schemas/
+        # sync. Version-scoped type stubs are also generated from those schema
+        # bundles and validated byte-for-byte by make validate-generated.
+        exclude: ^(schemas/|src/adcp/types/v(30|31|32)\.pyi$)
       - id: check-merge-conflict
       - id: check-case-conflict
       - id: detect-private-key
diff --git a/Makefile b/Makefile
index c68d27ca0..76a3037d6 100644
--- a/Makefile
+++ b/Makefile
@@ -79,6 +79,7 @@ regenerate-schemas: ## Download latest schemas and skills from bundle, then rege
 	$(PYTHON) scripts/fix_schema_refs.py
 	@echo "Bundling schemas into package..."
 	$(PYTHON) scripts/bundle_schemas.py
+	$(PYTHON) scripts/generate_versioned_stubs.py
 	@echo "Generating Pydantic models..."
 	$(PYTHON) scripts/generate_types.py
 	@echo "Consolidating exports..."
@@ -90,6 +91,7 @@ regenerate-schemas: ## Download latest schemas and skills from bundle, then rege
 validate-generated: ## Validate generated code (syntax and imports)
 	@echo "Validating generated code..."
 	@$(PYTHON) -m py_compile src/adcp/types/_generated.py
+	@$(PYTHON) scripts/generate_versioned_stubs.py --check
 	@echo "✓ Generated code validation passed"
 
 pre-push: format lint typecheck-all test validate-generated ## Run all checks before pushing (format, lint, typecheck, test, validate)
diff --git a/pyproject.toml b/pyproject.toml
index e1d56d2d2..6ea12768a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -175,6 +175,7 @@ namespaces = true
 [tool.setuptools.package-data]
 adcp = [
     "py.typed",
+    "types/*.pyi",
     "ADCP_VERSION",
     "signing/pg/*.sql",
     "decisioning/pg/*.sql",
@@ -210,7 +211,7 @@ target-version = ["py310", "py311", "py312"]
 # files, rolls back). The regen script already runs black on the
 # consolidated _generated.py; individual generated_poc/ files don't
 # need formatting at commit time. Mirrors the ruff extend-exclude.
-extend-exclude = "/(tasks|_generated|registry)\\.py$|/types/generated_poc/"
+extend-exclude = "/(tasks|_generated|registry)\\.py$|/types/generated_poc/|/types/v3[012]\\.pyi$"
 
 [tool.ruff]
 line-length = 100
@@ -220,6 +221,9 @@ extend-exclude = [
     "src/adcp/types/registry.py",
     "src/adcp/types/tasks.py",
     "src/adcp/types/generated_poc/",
+    "src/adcp/types/v30.pyi",
+    "src/adcp/types/v31.pyi",
+    "src/adcp/types/v32.pyi",
     "examples/",
     "scripts/",
 ]
diff --git a/scripts/generate_versioned_stubs.py b/scripts/generate_versioned_stubs.py
new file mode 100644
index 000000000..bc75b48a6
--- /dev/null
+++ b/scripts/generate_versioned_stubs.py
@@ -0,0 +1,571 @@
+#!/usr/bin/env python3
+"""Generate typed stubs for the dynamic version-scoped model modules.
+
+Runtime validation remains backed by the bundled JSON Schemas in
+``adcp.types.versioned``. These stubs give mypy and IDEs the corresponding
+field, constructor, nested-object, and requiredness information without
+introducing a second runtime validation implementation. Conditional JSON
+Schema constraints remain enforced at runtime by the bundled validator.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import keyword
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "src"))
+
+from adcp.validation.schema_loader import get_portable_schema, list_validator_keys  # noqa: E402
+
+VERSIONS = {"v30": "3.0", "v31": "3.1", "v32": "3.2-beta.0"}
+
+TYPING_STRUCTURE_KEYS = frozenset(
+    {"$ref", "allOf", "anyOf", "const", "enum", "oneOf", "properties", "type"}
+)
+
+
+def _has_typing_structure(schema: Any) -> bool:
+    return isinstance(schema, dict) and bool(TYPING_STRUCTURE_KEYS.intersection(schema))
+
+
+def _pascal(value: str) -> str:
+    value = value.replace("~1", "/").replace("~0", "~")
+    value = value.removesuffix(".json")
+    words = re.findall(r"[A-Za-z0-9]+", value)
+    return "".join(word[:1].upper() + word[1:] for word in words) or "Value"
+
+
+def _model_name(tool: str, direction: str) -> str:
+    suffix = {
+        "request": "Request",
+        "sync": "Response",
+        "submitted": "SubmittedResponse",
+        "working": "WorkingResponse",
+        "input-required": "InputRequiredResponse",
+    }[direction]
+    return f"{_pascal(tool)}{suffix}"
+
+
+def _literal(values: list[Any]) -> str:
+    return f"Literal[{', '.join(repr(value) for value in values)}]"
+
+
+def _intersect_property_schema(left: Any, right: Any) -> Any:
+    """Preserve useful intersections when allOf branches reuse a field."""
+    if left == right:
+        return left
+    if not isinstance(left, dict) or not isinstance(right, dict):
+        return {"allOf": [left, right]}
+
+    def finite_values(schema: dict[str, Any]) -> list[Any] | None:
+        if "const" in schema:
+            return [schema["const"]]
+        values = schema.get("enum")
+        return values if isinstance(values, list) else None
+
+    left_values = finite_values(left)
+    right_values = finite_values(right)
+    if left_values is not None and right_values is not None:
+        intersection = [value for value in left_values if value in right_values]
+        return {"enum": intersection}
+
+    left_type = left.get("type")
+    right_type = right.get("type")
+    if left_type is not None and left_type == right_type:
+        return {**left, **right}
+    left_types = set(left_type) if isinstance(left_type, list) else {left_type}
+    right_types = set(right_type) if isinstance(right_type, list) else {right_type}
+    common_types = (left_types & right_types) - {None}
+    if common_types:
+        schema_type: str | list[str]
+        schema_type = next(iter(common_types)) if len(common_types) == 1 else sorted(common_types)
+        return {**left, **right, "type": schema_type}
+    return {"allOf": [left, right]}
+
+
+def _merge_property_maps(left: dict[str, Any], right: dict[str, Any]) -> dict[str, Any]:
+    merged = dict(left)
+    for field, schema in right.items():
+        if field in merged:
+            merged[field] = _intersect_property_schema(merged[field], schema)
+        else:
+            merged[field] = schema
+    return merged
+
+
+class StubBuilder:
+    def __init__(
+        self,
+        model_name: str,
+        schema: dict[str, Any],
+        *,
+        definition_registry: dict[tuple[str, str], str],
+        object_registry: dict[tuple[str, str], str],
+        objects: dict[str, tuple[dict[str, Any], StubBuilder]],
+        used_names: set[str],
+    ) -> None:
+        self.model_name = model_name
+        self.schema = schema
+        self.definitions = schema.get("$defs", {})
+        self.definition_names: dict[str, str] = {}
+        self.definition_registry = definition_registry
+        self.object_registry = object_registry
+        self.objects = objects
+        self._used_names = used_names
+        self.local_reference_names: dict[str, str] = {}
+        for raw_name, definition in self.definitions.items():
+            fingerprint = json.dumps(definition, sort_keys=True, separators=(",", ":"))
+            registry_key = (raw_name, fingerprint)
+            name = definition_registry.get(registry_key)
+            if name is None:
+                name = self._unique_name(f"_{_pascal(raw_name)}")
+                definition_registry[registry_key] = name
+            self.definition_names[raw_name] = name
+
+    def _unique_name(self, candidate: str) -> str:
+        name = candidate
+        suffix = 2
+        while name in self._used_names:
+            name = f"{candidate}{suffix}"
+            suffix += 1
+        self._used_names.add(name)
+        return name
+
+    def _resolve_ref(self, reference: str) -> tuple[str, dict[str, Any]] | None:
+        prefix = "#/$defs/"
+        if reference.startswith(prefix):
+            raw_name = reference[len(prefix) :].replace("~1", "/").replace("~0", "~")
+            # Definition keys retain JSON Pointer escaping in some bundles and are
+            # decoded in others; support both representations deterministically.
+            definition = self.definitions.get(raw_name)
+            actual_name = raw_name
+            if definition is None:
+                encoded = raw_name.replace("~", "~0").replace("/", "~1")
+                definition = self.definitions.get(encoded)
+                actual_name = encoded
+            if definition is not None:
+                return self.definition_names[actual_name], definition
+
+        if not reference.startswith("#/"):
+            return None
+        target: Any = self.schema
+        for raw_segment in reference[2:].split("/"):
+            segment = raw_segment.replace("~1", "/").replace("~0", "~")
+            if isinstance(target, dict) and (segment in target or raw_segment in target):
+                target = target[segment] if segment in target else target[raw_segment]
+            elif isinstance(target, list) and segment.isdigit():
+                index = int(segment)
+                if index >= len(target):
+                    return None
+                target = target[index]
+            else:
+                return None
+        if not isinstance(target, dict):
+            return None
+        name = self.local_reference_names.get(reference)
+        if name is None:
+            fingerprint = json.dumps(target, sort_keys=True, separators=(",", ":"))
+            registry_key = (reference, fingerprint)
+            name = self.definition_registry.get(registry_key)
+            if name is None:
+                name = self._unique_name(f"_{_pascal(reference.rsplit('/', 1)[-1])}")
+                self.definition_registry[registry_key] = name
+            self.local_reference_names[reference] = name
+        return name, target
+
+    def _is_object(self, schema: Any) -> bool:
+        if not isinstance(schema, dict):
+            return False
+        if schema.get("type") == "object" or "properties" in schema:
+            return True
+        if "$ref" in schema:
+            resolved = self._resolve_ref(schema["$ref"])
+            return resolved is not None and self._is_object(resolved[1])
+        alternatives = schema.get("oneOf") or schema.get("anyOf")
+        if isinstance(alternatives, list) and alternatives:
+            return all(self._is_object(part) for part in alternatives)
+        all_of = schema.get("allOf")
+        if isinstance(all_of, list) and all_of:
+            typed_parts = [part for part in all_of if _has_typing_structure(part)]
+            return bool(typed_parts) and all(self._is_object(part) for part in typed_parts)
+        return False
+
+    def _finite_values(
+        self,
+        schema: dict[str, Any],
+        seen: frozenset[str] = frozenset(),
+    ) -> list[Any] | None:
+        if "const" in schema:
+            return [schema["const"]]
+        enum = schema.get("enum")
+        if isinstance(enum, list):
+            return enum
+        reference = schema.get("$ref")
+        if isinstance(reference, str) and reference not in seen:
+            resolved = self._resolve_ref(reference)
+            if resolved is not None:
+                return self._finite_values(resolved[1], seen | {reference})
+        all_of = schema.get("allOf")
+        if isinstance(all_of, list) and all_of:
+            constrained = [
+                values
+                for part in all_of
+                if isinstance(part, dict)
+                and (values := self._finite_values(part, seen)) is not None
+            ]
+            if constrained:
+                return [
+                    value
+                    for value in constrained[0]
+                    if all(value in values for values in constrained[1:])
+                ]
+        alternatives = schema.get("oneOf") or schema.get("anyOf")
+        if isinstance(alternatives, list) and alternatives:
+            rendered = [
+                self._finite_values(part, seen) for part in alternatives if isinstance(part, dict)
+            ]
+            if rendered and all(values is not None for values in rendered):
+                return list(dict.fromkeys(value for values in rendered for value in values or []))
+        return None
+
+    def type_expr(self, schema: Any, hint: str) -> str:
+        if schema is True:
+            return "Any"
+        if schema is False:
+            return "Never"
+        if not isinstance(schema, dict):
+            return "Any"
+        finite_values = self._finite_values(schema)
+        if finite_values is not None:
+            return _literal(finite_values) if finite_values else "Never"
+        if self._is_object(schema):
+            shapes = self.object_shapes(schema)
+            if len(shapes) > 1:
+                rendered = []
+                for index, (properties, required) in enumerate(shapes, 1):
+                    variant_schema: dict[str, Any] = {
+                        "type": "object",
+                        "properties": properties,
+                    }
+                    if required:
+                        variant_schema["required"] = sorted(required)
+                    rendered.append(self.type_expr(variant_schema, f"{hint}Variant{index}"))
+                return " | ".join(dict.fromkeys(rendered))
+        reference = schema.get("$ref")
+        if isinstance(reference, str):
+            resolved = self._resolve_ref(reference)
+            if resolved is not None:
+                name, definition = resolved
+                if self._is_object(definition):
+                    properties, _required = self.object_shape(definition)
+                    if not properties:
+                        additional = definition.get("additionalProperties")
+                        if isinstance(additional, dict):
+                            return (
+                                "builtins.dict[builtins.str, "
+                                f"{self.type_expr(additional, f'{name}Value')}]"
+                            )
+                        return "builtins.dict[builtins.str, Any]"
+                    self.objects.setdefault(name, (definition, self))
+                    return name
+                return self.type_expr(definition, name)
+        variants = schema.get("oneOf")
+        if not variants:
+            any_of = schema.get("anyOf")
+            if (
+                isinstance(any_of, list)
+                and any_of
+                and all(_has_typing_structure(part) for part in any_of)
+            ):
+                variants = any_of
+        if isinstance(variants, list) and variants:
+            rendered = [
+                self.type_expr(variant, f"{hint}Variant{index}")
+                for index, variant in enumerate(variants, 1)
+            ]
+            return " | ".join(dict.fromkeys(rendered))
+        all_of = schema.get("allOf")
+        if isinstance(all_of, list) and all_of and not self._is_object(schema):
+            rendered = list(
+                dict.fromkeys(
+                    self.type_expr(part, hint) for part in all_of if _has_typing_structure(part)
+                )
+            )
+            if len(rendered) == 1:
+                return rendered[0]
+        schema_type = schema.get("type")
+        if isinstance(schema_type, list):
+            rendered = [self.type_expr({**schema, "type": item}, hint) for item in schema_type]
+            return " | ".join(dict.fromkeys(rendered))
+        if schema_type == "array":
+            return f"builtins.list[{self.type_expr(schema.get('items', {}), f'{hint}Item')}]"
+        if self._is_object(schema):
+            properties, _ = self.object_shape(schema)
+            if not properties:
+                additional = schema.get("additionalProperties")
+                if isinstance(additional, dict):
+                    return (
+                        "builtins.dict[builtins.str, "
+                        f"{self.type_expr(additional, f'{hint}Value')}]"
+                    )
+                return "builtins.dict[builtins.str, Any]"
+            fingerprint = json.dumps(schema, sort_keys=True, separators=(",", ":"))
+            registry_key = (hint, fingerprint)
+            name = self.object_registry.get(registry_key)
+            if name is None:
+                candidate = hint if hint.startswith("_") else f"_{hint}"
+                name = self._unique_name(candidate)
+                self.object_registry[registry_key] = name
+            self.objects[name] = (schema, self)
+            return name
+        return {
+            "string": "builtins.str",
+            "integer": "builtins.int",
+            "number": "builtins.float",
+            "boolean": "builtins.bool",
+            "null": "None",
+        }.get(schema_type, "Any")
+
+    def object_shapes(
+        self, schema: dict[str, Any], seen: frozenset[str] = frozenset()
+    ) -> list[tuple[dict[str, Any], set[str]]]:
+        shapes: list[tuple[dict[str, Any], set[str]]] = [({}, set())]
+
+        def merge(
+            left: list[tuple[dict[str, Any], set[str]]],
+            right: list[tuple[dict[str, Any], set[str]]],
+        ) -> list[tuple[dict[str, Any], set[str]]]:
+            return [
+                (
+                    _merge_property_maps(left_properties, right_properties),
+                    left_required | right_required,
+                )
+                for left_properties, left_required in left
+                for right_properties, right_required in right
+            ]
+
+        reference = schema.get("$ref")
+        if isinstance(reference, str) and reference not in seen:
+            resolved = self._resolve_ref(reference)
+            if resolved is not None:
+                shapes = merge(shapes, self.object_shapes(resolved[1], seen | {reference}))
+        for part in schema.get("allOf", []):
+            if isinstance(part, dict):
+                shapes = merge(shapes, self.object_shapes(part, seen))
+        own_properties = schema.get("properties", {})
+        if not isinstance(own_properties, dict):
+            own_properties = {}
+        own_required = schema.get("required", [])
+        required = (
+            {item for item in own_required if isinstance(item, str)}
+            if isinstance(own_required, list)
+            else set()
+        )
+        shapes = [
+            (_merge_property_maps(properties, own_properties), shape_required | required)
+            for properties, shape_required in shapes
+        ]
+
+        # Expand exclusive structural alternatives. ``anyOf`` is often used
+        # only to express "at least one of these keys"; multiplying those
+        # requiredness combinations creates enormous stubs without improving
+        # the nested value types, so exact enforcement remains with JSON Schema.
+        alternatives = schema.get("oneOf")
+        if isinstance(alternatives, list) and alternatives:
+            alternative_shapes = [
+                shape
+                for alternative in alternatives
+                if isinstance(alternative, dict)
+                for shape in self.object_shapes(alternative, seen)
+            ]
+            if alternative_shapes:
+                shapes = merge(shapes, alternative_shapes)
+        return shapes
+
+    def object_shape(self, schema: dict[str, Any]) -> tuple[dict[str, Any], set[str]]:
+        shapes = self.object_shapes(schema)
+        if len(shapes) != 1:
+            raise ValueError("union object must be rendered as separate TypedDict variants")
+        return shapes[0]
+
+    def render_model(self) -> list[str]:
+        shapes = self.object_shapes(self.schema)
+        top_level_defaults = {
+            field
+            for field, field_schema in self.schema.get("properties", {}).items()
+            if isinstance(field_schema, dict) and "default" in field_schema
+        }
+
+        all_fields = dict.fromkeys(
+            field for properties, _required in shapes for field in properties
+        )
+        field_types: dict[str, str] = {}
+        constructor_types: dict[str, str] = {}
+        shape_field_types = [
+            {
+                field: self.type_expr(
+                    field_schema,
+                    f"{self.model_name}{_pascal(field)}",
+                )
+                for field, field_schema in properties.items()
+                if field.isidentifier() and not keyword.iskeyword(field)
+            }
+            for properties, _required in shapes
+        ]
+        for field in all_fields:
+            if not field.isidentifier() or keyword.iskeyword(field):
+                # JSON object keys that cannot be passed as Python keyword
+                # arguments remain available through ``root`` construction.
+                continue
+            annotations = [types[field] for types in shape_field_types if field in types]
+            constructor_type = " | ".join(dict.fromkeys(annotations))
+            constructor_types[field] = constructor_type
+            guaranteed = field in top_level_defaults or all(
+                field in required for _properties, required in shapes
+            )
+            field_types[field] = (
+                constructor_type
+                if guaranteed or "None" in constructor_type.split(" | ")
+                else f"{constructor_type} | None"
+            )
+
+        model_lines = [f"class {self.model_name}(VersionedSchemaModel):"]
+        if not field_types:
+            model_lines.append("    pass")
+            return model_lines
+        for field, annotation in field_types.items():
+            model_lines.append(f"    {field}: {annotation}")
+        model_lines.extend(
+            [
+                "",
+                "    @overload",
+                "    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...",
+            ]
+        )
+        for shape_index, (properties, required) in enumerate(shapes):
+            keyword_fields = [field for field in properties if field in constructor_types]
+            ordered_fields = [
+                *[field for field in keyword_fields if field in required],
+                *[field for field in keyword_fields if field not in required],
+            ]
+            model_lines.extend(
+                [
+                    "",
+                    "    @overload",
+                    "    def __init__(",
+                    "        self,",
+                    "        *,",
+                ]
+            )
+            for field in ordered_fields:
+                default = "" if field in required else " = ..."
+                model_lines.append(
+                    f"        {field}: {shape_field_types[shape_index][field]}{default},"
+                )
+            model_lines.append("    ) -> None: ...")
+        return model_lines
+
+
+def _render_objects(objects: dict[str, tuple[dict[str, Any], StubBuilder]]) -> list[str]:
+    lines: list[str] = []
+    rendered: set[str] = set()
+    while True:
+        pending = [
+            (name, schema, owner)
+            for name, (schema, owner) in objects.items()
+            if name not in rendered
+        ]
+        if not pending:
+            break
+        for name, schema, owner in pending:
+            rendered.add(name)
+            properties, required = owner.object_shape(schema)
+            lines.append(f"class {name}(TypedDict, total=False):")
+            if not properties:
+                lines.append("    pass")
+            for field, field_schema in properties.items():
+                if not field.isidentifier() or keyword.iskeyword(field):
+                    continue
+                annotation = owner.type_expr(field_schema, f"{name}{_pascal(field)}")
+                wrapper = "Required" if field in required else "NotRequired"
+                lines.append(f"    {field}: {wrapper}[{annotation}]")
+            lines.append("")
+    return lines
+
+
+def generate(module: str, version: str) -> str:
+    header = [
+        '"""Generated typing surface for the dynamic version-scoped models."""',
+        "",
+        "from __future__ import annotations",
+        "",
+        "import builtins",
+        "from typing import Any, Literal, overload",
+        "from typing_extensions import Never, NotRequired, Required, TypedDict",
+        "",
+        "from adcp.types.versioned import VersionedSchemaModel",
+        "",
+        "# Underscored TypedDicts are private stub details used to type nested values.",
+        "# Runtime composition remains dict-based through the public boundary models.",
+        "",
+    ]
+    model_blocks: list[str] = []
+    exported: list[str] = []
+    definition_registry: dict[tuple[str, str], str] = {}
+    object_registry: dict[tuple[str, str], str] = {}
+    objects: dict[str, tuple[dict[str, Any], StubBuilder]] = {}
+    used_names = {_model_name(*key.split("::", 1)) for key in list_validator_keys(version=version)}
+    for key in list_validator_keys(version=version):
+        tool, direction = key.split("::", 1)
+        name = _model_name(tool, direction)
+        schema = get_portable_schema(tool, direction, version=version)
+        if schema is None:
+            continue
+        builder = StubBuilder(
+            name,
+            schema,
+            definition_registry=definition_registry,
+            object_registry=object_registry,
+            objects=objects,
+            used_names=used_names,
+        )
+        model_blocks.extend(builder.render_model())
+        model_blocks.append("")
+        exported.append(name)
+    blocks = [*_render_objects(objects), *model_blocks]
+    blocks.append(f"__all__ = {exported!r}")
+    blocks.append("")
+    return "\n".join([*header, *blocks])
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    stale: list[Path] = []
+    for module, version in VERSIONS.items():
+        path = ROOT / "src" / "adcp" / "types" / f"{module}.pyi"
+        content = generate(module, version)
+        if args.check:
+            if not path.exists() or path.read_text() != content:
+                stale.append(path)
+        else:
+            path.write_text(content)
+            print(f"Generated {path.relative_to(ROOT)}")
+    if stale:
+        print("Versioned type stubs are stale:", file=sys.stderr)
+        for path in stale:
+            print(f"  {path.relative_to(ROOT)}", file=sys.stderr)
+        print("Run: python scripts/generate_versioned_stubs.py", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/adcp/decisioning/__init__.py b/src/adcp/decisioning/__init__.py
index 20ad5f4d4..f7d6d5e08 100644
--- a/src/adcp/decisioning/__init__.py
+++ b/src/adcp/decisioning/__init__.py
@@ -40,9 +40,7 @@ def create_media_buy(
             return CreateMediaBuySuccess(media_buy_id=f"mb_{req.idempotency_key}", ...)
 
 
-    serve(create_adcp_server_from_platform(
-        platform=HelloSeller(), name="hello-seller", version="0.0.1",
-    ))
+    serve(HelloSeller(), name="hello-seller")
 
 See ``examples/hello_seller.py`` for the runnable version.
 """
diff --git a/src/adcp/decisioning/handler.py b/src/adcp/decisioning/handler.py
index 6dfff77a8..49f9f2319 100644
--- a/src/adcp/decisioning/handler.py
+++ b/src/adcp/decisioning/handler.py
@@ -38,6 +38,7 @@
 from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 
+from adcp._version import resolve_adcp_version
 from adcp.decisioning._get_products_helpers import _project_product_fields
 from adcp.decisioning.account_projection import (
     strip_credentials_from_wire_result,
@@ -1352,8 +1353,13 @@ def __init__(
         media_buy_store: MediaBuyStore | None = None,
         advertise_all: bool = False,
         timed_sync_get_products_limit: int | None = None,
+        adcp_version: str | None = None,
     ) -> None:
         super().__init__()
+        # ``None`` resolves to the protocol version bundled with this SDK, so
+        # every PlatformHandler has a concrete pin for schema discovery and
+        # unnegotiated dispatch.
+        self._adcp_version = resolve_adcp_version(adcp_version)
         self._platform = platform
         self._executor = executor
         self._registry = registry
@@ -1402,6 +1408,10 @@ def __init__(
                 stacklevel=2,
             )
 
+    def get_adcp_version(self) -> str:
+        """Return the concrete AdCP protocol version pinned to this handler."""
+        return self._adcp_version
+
     # ----- account resolution helper -----
 
     async def _prime_auth_context(self, ctx: ToolContext) -> None:
diff --git a/src/adcp/decisioning/serve.py b/src/adcp/decisioning/serve.py
index bc560a542..f2be35fc3 100644
--- a/src/adcp/decisioning/serve.py
+++ b/src/adcp/decisioning/serve.py
@@ -35,6 +35,7 @@
 from dataclasses import replace
 from typing import TYPE_CHECKING, Any
 
+from adcp._version import resolve_adcp_version
 from adcp.decisioning.dispatch import validate_platform
 from adcp.decisioning.handler import PlatformHandler
 from adcp.decisioning.task_registry import InMemoryTaskRegistry
@@ -98,6 +99,7 @@ def create_adcp_server_from_platform(
     media_buy_store: MediaBuyStore | None = None,
     advertise_all: bool = False,
     validate_at_init: bool = True,
+    adcp_version: str | None = None,
 ) -> tuple[PlatformHandler, ThreadPoolExecutor, TaskRegistry]:
     """Build the :class:`PlatformHandler` + supporting wiring from a
     :class:`DecisioningPlatform`.
@@ -120,6 +122,8 @@ def create_adcp_server_from_platform(
 
     :param platform: The adopter's :class:`DecisioningPlatform`
         subclass instance.
+    :param adcp_version: Protocol version pin used for discovery schemas and
+        unnegotiated dispatch. ``None`` uses the SDK's packaged protocol pin.
     :param executor: Bring-your-own :class:`ThreadPoolExecutor` —
         for operators with audit-instrumented thread pools or
         wrappers around stdlib's executor. Mutually exclusive with
@@ -263,6 +267,10 @@ def create_adcp_server_from_platform(
         gate refuses :class:`InMemoryTaskRegistry`.
     """
     # D5: executor / thread_pool_size mutually exclusive.
+    # Validate before allocating a framework-owned executor so a bad public
+    # pin cannot leak a worker pool during construction.
+    resolved_adcp_version = resolve_adcp_version(adcp_version)
+
     if executor is not None and thread_pool_size is not None:
         raise ValueError(
             "Pass either executor= or thread_pool_size=, not both. "
@@ -403,6 +411,7 @@ def create_adcp_server_from_platform(
         media_buy_store=media_buy_store,
         advertise_all=advertise_all,
         timed_sync_get_products_limit=resolved_timed_sync_limit,
+        adcp_version=resolved_adcp_version,
     )
 
     # Boot-time fail-fast: property_list_filtering declared but no fetcher wired.
@@ -500,11 +509,13 @@ def serve(
     brand_identity_resolver: BrandIdentityResolver | None = None,
     config_store: ProductConfigStore | None = None,
     property_list_fetcher: PropertyListFetcher | None = None,
+    media_buy_store: MediaBuyStore | None = None,
     advertise_all: bool = False,
     mock_ad_server: Any | None = None,
     enable_debug_endpoints: bool = False,
     pre_validation_hooks: dict[str, Any] | None = None,
     validate_at_init: bool = True,
+    adcp_version: str | None = None,
     **serve_kwargs: Any,
 ) -> None:
     """One-call wrapper — build the handler and serve over MCP.
@@ -515,6 +526,8 @@ def serve(
 
     :param platform: The :class:`DecisioningPlatform` subclass
         instance.
+    :param adcp_version: Protocol version pin used for discovery schemas and
+        unnegotiated dispatch. ``None`` uses the SDK's packaged protocol pin.
     :param name: Server name advertised on AdCP capabilities. Defaults
         to the platform class's ``__name__``.
     :param executor: BYO :class:`ThreadPoolExecutor` per
@@ -631,8 +644,10 @@ def serve(
         brand_identity_resolver=brand_identity_resolver,
         config_store=config_store,
         property_list_fetcher=property_list_fetcher,
+        media_buy_store=media_buy_store,
         advertise_all=advertise_all,
         validate_at_init=validate_at_init,
+        adcp_version=adcp_version,
     )
 
     # Phase 1 sandbox-authority — wire the comply controller's account
diff --git a/src/adcp/migrate/v3_to_v4.py b/src/adcp/migrate/v3_to_v4.py
index 4949caf4f..7762b0c37 100644
--- a/src/adcp/migrate/v3_to_v4.py
+++ b/src/adcp/migrate/v3_to_v4.py
@@ -166,6 +166,38 @@
     "ReportingWebhook": "adcp.types.ReportingWebhook",
 }
 
+# Collision-safe mappings whose replacement depends on the defining private
+# module. Numbered codegen names cannot be mapped safely by symbol alone: the
+# same bare name may describe a different schema in another generated module.
+GENERATED_POC_SOURCE_SYMBOL_MAP: dict[tuple[str, str], str] = {
+    ("core.account_ref", "AccountReference1"): "adcp.types.AccountIdReference",
+    ("core.account_ref", "AccountReference2"): "adcp.types.InlineAccountReference",
+    ("core.vendor_pricing_option", "VendorPricingOption"): ("adcp.types.VendorPricingOptionUnion"),
+    ("core.vendor_pricing_option", "VendorPricingOption1"): ("adcp.types.CpmVendorPricingOption"),
+    ("core.vendor_pricing_option", "VendorPricingOption2"): (
+        "adcp.types.PercentOfMediaVendorPricingOption"
+    ),
+    ("core.vendor_pricing_option", "VendorPricingOption3"): (
+        "adcp.types.FlatFeeVendorPricingOption"
+    ),
+    ("core.vendor_pricing_option", "VendorPricingOption4"): (
+        "adcp.types.PerUnitVendorPricingOption"
+    ),
+    ("core.vendor_pricing_option", "VendorPricingOption5"): (
+        "adcp.types.CustomVendorPricingOption"
+    ),
+    ("core.product_allocation", "ProductAllocation"): "adcp.types.ProductAllocation",
+    ("core.product", "TrustedMatch"): "adcp.types.TrustedMatch",
+    ("core.signal_coverage_forecast", "SignalCoverageForecast"): (
+        "adcp.types.SignalCoverageForecast"
+    ),
+    ("signals.get_signals_response", "Range"): "adcp.types.SignalCoverageRange",
+    ("core.missing_metric", "MissingMetric"): "adcp.types.MissingMetric",
+    ("media_buy.update_media_buy_response", "UpdateMediaBuyResponse2"): (
+        "adcp.types.LegacyUpdateMediaBuyErrorResponse"
+    ),
+}
+
 
 # ``from adcp.types.generated_poc.<...> import <Symbol[, ...]>`` —
 # captures the symbol list so we can emit per-symbol replacement hints.
@@ -173,10 +205,17 @@
 # fall through to the generic "private module" flag, which still
 # surfaces the issue and prints the migration anchor.
 _GENERATED_POC_FROM_IMPORT = re.compile(
-    r"from\s+adcp\.types\.generated_poc(?:\.[\w.]+)?\s+import\s+([\w\s,]+)"
+    r"from\s+adcp\.types\.generated_poc"
+    r"(?:\.(?P<module>[\w.]+))?\s+import\s+(?P<symbols>[\w \t,]+)"
 )
 
 
+def _generated_symbol_replacement(module: str, symbol: str) -> str | None:
+    return GENERATED_POC_SOURCE_SYMBOL_MAP.get((module, symbol)) or GENERATED_POC_SYMBOL_MAP.get(
+        symbol
+    )
+
+
 # Regex for numbered Assets direct imports (``Assets5``, ``Assets14``, etc).
 # Bare ``Assets`` (no digits) is a legitimate base class alias; the
 # regex requires at least one digit to avoid false positives.
@@ -328,18 +367,6 @@ def _iter_python_files(root: Path) -> list[Path]:
     name: re.compile(rf"\b{re.escape(name)}\b") for name in NUMBERED_ASSETS_RENAMES
 }
 
-# Regex used in the ``--auto-apply`` import-path fix pass: matches the
-# ``from adcp.types.generated_poc...`` prefix so it can be replaced with
-# ``from adcp.types``.
-_GENERATED_POC_MODULE_RE = re.compile(r"from\s+adcp\.types\.generated_poc(?:\.[\w.]+)?\s+import")
-
-# Union of symbol names that ``--auto-apply`` can safely reroute to
-# ``adcp.types``: the explicit flag_private symbol map plus every public
-# alias produced by a numbered-assets rename.
-_AUTO_APPLY_PUBLIC_SYMBOLS: frozenset[str] = frozenset(
-    set(GENERATED_POC_SYMBOL_MAP.keys()) | set(NUMBERED_ASSETS_RENAMES.values())
-)
-
 
 def scan_file(
     path: Path, *, apply_changes: bool, auto_apply: bool = False
@@ -392,10 +419,14 @@ def scan_file(
         if "adcp.types.generated_poc" in line:
             from_match = _GENERATED_POC_FROM_IMPORT.search(line)
             if from_match:
-                raw_syms = [s.strip() for s in from_match.group(1).split(",")]
+                module = from_match.group("module") or ""
+                raw_syms = [s.strip() for s in from_match.group("symbols").split(",")]
                 pre_syms = [r.split(" as ")[0].strip() for r in raw_syms if r.strip()]
-                post_syms = [NUMBERED_ASSETS_RENAMES.get(s, s) for s in pre_syms]
-                if pre_syms and not all(s in _AUTO_APPLY_PUBLIC_SYMBOLS for s in post_syms):
+                if pre_syms and not all(
+                    _generated_symbol_replacement(module, symbol) is not None
+                    or symbol in NUMBERED_ASSETS_RENAMES
+                    for symbol in pre_syms
+                ):
                     line_is_mixed_unsafe_import = True
 
         for old, new in ASSET_CONTENT_RENAMES.items():
@@ -484,7 +515,8 @@ def scan_file(
             col = line.index(private_path) + 1
             from_match = _GENERATED_POC_FROM_IMPORT.search(line)
             if from_match:
-                raw_symbols = [s.strip() for s in from_match.group(1).split(",")]
+                module = from_match.group("module") or ""
+                raw_symbols = [s.strip() for s in from_match.group("symbols").split(",")]
                 parsed: list[tuple[str, str | None]] = []
                 for raw in raw_symbols:
                     raw = raw.strip()
@@ -493,7 +525,7 @@ def scan_file(
                     symbol = raw.split(" as ")[0].strip()
                     if not symbol:
                         continue
-                    parsed.append((symbol, GENERATED_POC_SYMBOL_MAP.get(symbol)))
+                    parsed.append((symbol, _generated_symbol_replacement(module, symbol)))
 
                 if not parsed:
                     findings.append(
@@ -530,7 +562,8 @@ def scan_file(
                                 before=symbol,
                                 after=replacement,
                                 hint=(
-                                    f"private module — import {symbol} from "
+                                    "private module — import "
+                                    f"{replacement.rsplit('.', 1)[-1]} from "
                                     "adcp.types (stable public API) instead"
                                 ),
                             )
@@ -624,18 +657,38 @@ def scan_file(
             if is_generated_poc_import:
                 m = _GENERATED_POC_FROM_IMPORT.search(text_line)
                 assert m is not None  # narrowed above
-                raw_syms = [s.strip() for s in m.group(1).split(",")]
+                module = m.group("module") or ""
+                raw_syms = [s.strip() for s in m.group("symbols").split(",")]
                 pre_syms = [r.split(" as ")[0].strip() for r in raw_syms if r.strip()]
-                # Apply the hypothetical numbered rename to each symbol
-                # so we can check if the *post-rename* symbol set is
-                # safe.
-                post_syms = [NUMBERED_ASSETS_RENAMES.get(s, s) for s in pre_syms]
-                if post_syms and all(s in _AUTO_APPLY_PUBLIC_SYMBOLS for s in post_syms):
-                    # Whole import is safe — substitute numbered names
-                    # AND fix the module path.
-                    for old, new in NUMBERED_ASSETS_RENAMES.items():
-                        text_line = _NUMBERED_RENAME_PATTERNS[old].sub(new, text_line)
-                    text_line = _GENERATED_POC_MODULE_RE.sub("from adcp.types import", text_line)
+                replacements = [
+                    _generated_symbol_replacement(module, symbol)
+                    or (
+                        f"adcp.types.{NUMBERED_ASSETS_RENAMES[symbol]}"
+                        if symbol in NUMBERED_ASSETS_RENAMES
+                        else None
+                    )
+                    for symbol in pre_syms
+                ]
+                if replacements and all(replacement is not None for replacement in replacements):
+                    public_imports: list[str] = []
+                    for raw, symbol, replacement in zip(
+                        raw_syms, pre_syms, replacements, strict=True
+                    ):
+                        assert replacement is not None
+                        public_name = replacement.rsplit(".", 1)[-1]
+                        local_name = raw.split(" as ", 1)[1].strip() if " as " in raw else None
+                        if local_name is not None:
+                            public_imports.append(f"{public_name} as {local_name}")
+                        elif symbol in NUMBERED_ASSETS_RENAMES:
+                            public_imports.append(public_name)
+                        elif public_name != symbol:
+                            # Preserve existing use sites while moving the import
+                            # to the semantic public name.
+                            public_imports.append(f"{public_name} as {symbol}")
+                        else:
+                            public_imports.append(public_name)
+                    replacement_import = "from adcp.types import " + ", ".join(public_imports)
+                    text_line = text_line[: m.start()] + replacement_import + text_line[m.end() :]
                 # Mixed line — leave it alone. The findings list still
                 # carries the per-symbol flag_private and flag_numbered
                 # entries so the adopter sees the work to do.
diff --git a/src/adcp/server/a2a_server.py b/src/adcp/server/a2a_server.py
index 49a1f0195..25b72d1ff 100644
--- a/src/adcp/server/a2a_server.py
+++ b/src/adcp/server/a2a_server.py
@@ -133,7 +133,11 @@ async def agent_card_url(request: Request) -> str:
 """
 
 
-from adcp.server.mcp_tools import create_tool_caller, get_tools_for_handler
+from adcp.server.mcp_tools import (
+    _resolve_handler_adcp_version,
+    create_tool_caller,
+    get_tools_for_handler,
+)
 from adcp.server.test_controller import TestControllerStore, _handle_test_controller
 
 logger = logging.getLogger(__name__)
@@ -246,7 +250,12 @@ def __init__(
         # Skip comply_test_controller unless the seller passed a
         # TestControllerStore; otherwise we would advertise a skill
         # backed only by the handler's not-supported stub.
-        tool_defs = get_tools_for_handler(handler, advertise_all=advertise_all)
+        resolved_adcp_version = _resolve_handler_adcp_version(handler, None)
+        tool_defs = get_tools_for_handler(
+            handler,
+            advertise_all=advertise_all,
+            adcp_version=resolved_adcp_version,
+        )
         for tool_def in tool_defs:
             name = tool_def["name"]
             if name == "comply_test_controller" and test_controller is None:
@@ -257,7 +266,7 @@ def __init__(
                 name,
                 validation=validation,
                 pre_validation_hook=hook,
-                default_unnegotiated_adcp_version=None,
+                default_unnegotiated_adcp_version=resolved_adcp_version,
                 response_enhancer=response_enhancer,
             )
 
diff --git a/src/adcp/server/serve.py b/src/adcp/server/serve.py
index 56523304a..e0a1bec49 100644
--- a/src/adcp/server/serve.py
+++ b/src/adcp/server/serve.py
@@ -1674,11 +1674,11 @@ async def _serve() -> None:
         sock.close()
 
 
-def _serve_a2a(
+def _build_a2a_app(
     handler: ADCPHandler[Any],
     *,
     name: str,
-    port: int | None,
+    port: int,
     test_controller: TestControllerStore | None,
     test_controller_account_resolver: Any | None = None,
     context_factory: ContextFactory | None = None,
@@ -1698,20 +1698,18 @@ def _serve_a2a(
     description: str | None = None,
     auth: BearerTokenAuth | None = None,
     public_url: str | PublicUrlResolver | None = None,
-) -> None:
-    """Start an A2A server using uvicorn."""
-    import uvicorn
-
+    include_discovery: bool = True,
+) -> Any:
+    """Build the production A2A ASGI app without binding a socket."""
     from adcp.server.a2a_server import create_a2a_server
     from adcp.server.discovery import resolve_base_url
 
-    resolved_port = port or int(os.environ.get("PORT", "3001"))
-    resolved_base_url = resolve_base_url("0.0.0.0", resolved_port, base_url)
+    resolved_base_url = resolve_base_url("0.0.0.0", port, base_url)
 
     app = create_a2a_server(
         handler,
         name=name,
-        port=resolved_port,
+        port=port,
         test_controller=test_controller,
         test_controller_account_resolver=test_controller_account_resolver,
         context_factory=context_factory,
@@ -1732,16 +1730,72 @@ def _serve_a2a(
     # wrappers) so bad tokens 401 before the request hits any
     # operator-supplied layer.
     app = _wrap_a2a_with_auth(app, auth)
-    app = _wrap_with_discovery(
-        app,
+    if include_discovery:
+        app = _wrap_with_discovery(
+            app,
+            name=name,
+            transports=["a2a"],
+            base_url=resolved_base_url,
+            description=description,
+            specialisms=specialisms,
+        )
+    app = _wrap_with_size_limit(app, max_request_size)
+    return _apply_asgi_middleware(app, asgi_middleware)
+
+
+def _serve_a2a(
+    handler: ADCPHandler[Any],
+    *,
+    name: str,
+    port: int | None,
+    test_controller: TestControllerStore | None,
+    test_controller_account_resolver: Any | None = None,
+    context_factory: ContextFactory | None = None,
+    task_store: TaskStore | None = None,
+    push_config_store: PushNotificationConfigStore | None = None,
+    push_sender: PushNotificationSender | None = None,
+    middleware: Sequence[SkillMiddleware] | None = None,
+    asgi_middleware: Sequence[ASGIMiddlewareEntry] | None = None,
+    message_parser: MessageParser | None = None,
+    advertise_all: bool = False,
+    max_request_size: int | None = None,
+    validation: ValidationHookConfig | None = DEFAULT_VALIDATION,
+    pre_validation_hooks: PreValidationHooks | None = None,
+    response_enhancer: ResponseEnhancer | None = None,
+    base_url: str | None = None,
+    specialisms: list[str] | None = None,
+    description: str | None = None,
+    auth: BearerTokenAuth | None = None,
+    public_url: str | PublicUrlResolver | None = None,
+) -> None:
+    """Start an A2A server using uvicorn."""
+    import uvicorn
+
+    resolved_port = port or int(os.environ.get("PORT", "3001"))
+    app = _build_a2a_app(
+        handler,
         name=name,
-        transports=["a2a"],
-        base_url=resolved_base_url,
-        description=description,
+        port=resolved_port,
+        test_controller=test_controller,
+        test_controller_account_resolver=test_controller_account_resolver,
+        context_factory=context_factory,
+        task_store=task_store,
+        push_config_store=push_config_store,
+        push_sender=push_sender,
+        middleware=middleware,
+        asgi_middleware=asgi_middleware,
+        message_parser=message_parser,
+        advertise_all=advertise_all,
+        max_request_size=max_request_size,
+        validation=validation,
+        pre_validation_hooks=pre_validation_hooks,
+        response_enhancer=response_enhancer,
+        base_url=base_url,
         specialisms=specialisms,
+        description=description,
+        auth=auth,
+        public_url=public_url,
     )
-    app = _wrap_with_size_limit(app, max_request_size)
-    app = _apply_asgi_middleware(app, asgi_middleware)
     sock = _bind_reusable_socket("0.0.0.0", resolved_port)
     try:
         # Same bind-boundary INFO as the MCP path so A2A adopters
@@ -1794,6 +1848,7 @@ def _build_mcp_and_a2a_app(
     public_url: str | PublicUrlResolver | None = None,
     on_startup: Sequence[LifespanHook] | None = None,
     on_shutdown: Sequence[LifespanHook] | None = None,
+    include_discovery: bool = True,
 ) -> Any:
     """Build the unified MCP+A2A ASGI app without starting a server.
 
@@ -2006,14 +2061,15 @@ async def _dispatch(scope: Scope, receive: Receive, send: Send) -> None:
     from adcp.server.discovery import resolve_base_url
 
     resolved_base_url = resolve_base_url(host, port, base_url)
-    app = _wrap_with_discovery(
-        app,
-        name=name,
-        transports=["mcp", "a2a"],
-        base_url=resolved_base_url,
-        description=description,
-        specialisms=specialisms,
-    )
+    if include_discovery:
+        app = _wrap_with_discovery(
+            app,
+            name=name,
+            transports=["mcp", "a2a"],
+            base_url=resolved_base_url,
+            description=description,
+            specialisms=specialisms,
+        )
     return _wrap_with_size_limit(app, max_request_size)
 
 
diff --git a/src/adcp/testing/decisioning.py b/src/adcp/testing/decisioning.py
index e3fbf97f5..c303d0eb5 100644
--- a/src/adcp/testing/decisioning.py
+++ b/src/adcp/testing/decisioning.py
@@ -26,7 +26,7 @@
 from __future__ import annotations
 
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 from urllib.parse import urlparse
 
 from adcp.decisioning.context import RequestContext
@@ -137,6 +137,7 @@ def make_request_context(
 def build_asgi_app(
     platform: DecisioningPlatform,
     *,
+    transport: Literal["mcp", "a2a", "both"] = "mcp",
     name: str | None = None,
     advertise_all: bool = False,
     auto_emit_completion_webhooks: bool = False,
@@ -164,6 +165,10 @@ def build_asgi_app(
     ``httpx.ASGITransport``, ``starlette.testclient.TestClient``, or any
     ASGI test harness.
 
+    ``transport="mcp"`` maps to production's
+    ``transport="streamable-http"`` spelling. ``"a2a"`` and ``"both"``
+    use the same app builders as their production counterparts.
+
     The wrapping order mirrors production
     (``_run_mcp_http`` in ``adcp.server.serve``):
 
@@ -179,6 +184,9 @@ def build_asgi_app(
 
     :param platform: The :class:`DecisioningPlatform` instance under
         test.
+    :param transport: In-process transport topology: ``"mcp"`` (the
+        production ``"streamable-http"`` transport), ``"a2a"``, or
+        ``"both"``. Defaults to ``"mcp"`` for backward compatibility.
     :param name: Server name on the AdCP capabilities envelope. Defaults
         to ``type(platform).__name__``.
     :param advertise_all: Forwarded to
@@ -247,9 +255,14 @@ def build_asgi_app(
         ``starlette.testclient.TestClient``,
         ``httpx.AsyncClient(app=app, ...)``, or any ASGI test harness.
     """
+    if transport not in ("mcp", "a2a", "both"):
+        raise ValueError(f"Unsupported transport {transport!r}; expected 'mcp', 'a2a', or 'both'.")
+
     from adcp.decisioning.serve import create_adcp_server_from_platform
     from adcp.server.serve import (
         _apply_asgi_middleware,
+        _build_a2a_app,
+        _build_mcp_and_a2a_app,
         _wrap_mcp_with_auth,
         _wrap_with_path_normalize,
         _wrap_with_size_limit,
@@ -263,6 +276,52 @@ def build_asgi_app(
         **factory_kwargs,
     )
     server_name = name or type(platform).__name__
+    if transport == "both":
+        # TODO(#1047): expose A2A-only message_parser/public_url and task /
+        # push stores explicitly once the public testing signature owns them.
+        app = _build_mcp_and_a2a_app(
+            handler,
+            name=server_name,
+            port=0,
+            host="127.0.0.1",
+            instructions=None,
+            test_controller=None,
+            context_factory=context_factory,
+            middleware=middleware,
+            advertise_all=advertise_all,
+            max_request_size=max_request_size,
+            streaming_responses=streaming_responses,
+            validation=validation,
+            pre_validation_hooks=pre_validation_hooks,
+            response_enhancer=response_enhancer,
+            base_url=discovery_base_url,
+            allowed_hosts=allowed_hosts,
+            allowed_origins=allowed_origins,
+            enable_dns_rebinding_protection=enable_dns_rebinding_protection,
+            auth=auth,
+            include_discovery=discovery_base_url is not None,
+        )
+        return _apply_asgi_middleware(app, asgi_middleware)
+    if transport == "a2a":
+        # TODO(#1047): expose A2A-only message_parser/public_url and task /
+        # push stores explicitly once the public testing signature owns them.
+        return _build_a2a_app(
+            handler,
+            name=server_name,
+            port=0,
+            test_controller=None,
+            context_factory=context_factory,
+            middleware=middleware,
+            asgi_middleware=asgi_middleware,
+            advertise_all=advertise_all,
+            max_request_size=max_request_size,
+            validation=validation,
+            pre_validation_hooks=pre_validation_hooks,
+            response_enhancer=response_enhancer,
+            base_url=discovery_base_url,
+            auth=auth,
+            include_discovery=discovery_base_url is not None,
+        )
     mcp = create_mcp_server(
         handler,
         name=server_name,
@@ -302,6 +361,7 @@ async def build_test_client(
     platform: DecisioningPlatform,
     *,
     base_url: str = "http://test",
+    transport: Literal["mcp", "a2a", "both"] = "mcp",
     name: str | None = None,
     advertise_all: bool = False,
     auto_emit_completion_webhooks: bool = False,
@@ -348,6 +408,7 @@ async def build_test_client(
     :param base_url: Base URL for all requests. Default ``"http://test"``.
         The hostname is extracted and added to the transport-security
         ``allowed_hosts`` list automatically — no manual wiring needed.
+    :param transport: Forwarded to :func:`build_asgi_app`.
     :param name: Server name forwarded to :func:`build_asgi_app`.
     :param advertise_all: Forwarded to :func:`build_asgi_app`.
     :param auto_emit_completion_webhooks: Forwarded to :func:`build_asgi_app`.
@@ -420,6 +481,7 @@ async def build_test_client(
     # regardless. Only the capabilities-shape validator is gated.
     app = build_asgi_app(
         platform,
+        transport=transport,
         name=name,
         advertise_all=advertise_all,
         auto_emit_completion_webhooks=auto_emit_completion_webhooks,
diff --git a/src/adcp/types/__init__.py b/src/adcp/types/__init__.py
index d5da9e76b..4e4dd230f 100644
--- a/src/adcp/types/__init__.py
+++ b/src/adcp/types/__init__.py
@@ -706,6 +706,7 @@
     "UpdateContentStandardsResponse1",
     "UpdateContentStandardsSuccessResponse",
     "UpdateMediaBuyErrorResponse",
+    "LegacyUpdateMediaBuyErrorResponse",
     "UpdateMediaBuyResponse1",
     "UpdateMediaBuyResponse3",
     "UpdateMediaBuyPackagesRequest",
@@ -821,6 +822,20 @@
     # Response-shape projection helpers
     "project_geo_postal_areas",
     "to_account_response",
+    # Collision-safe migration aliases (#911 remaining inventory)
+    "AccountIdReference",
+    "InlineAccountReference",
+    "VendorPricingOptionUnion",
+    "CpmVendorPricingOption",
+    "PercentOfMediaVendorPricingOption",
+    "FlatFeeVendorPricingOption",
+    "PerUnitVendorPricingOption",
+    "CustomVendorPricingOption",
+    "ProductAllocation",
+    "TrustedMatch",
+    "SignalCoverageForecast",
+    "SignalCoverageRange",
+    "MissingMetric",
     # Cross-module name collision aliases (#911, Step 2)
     # Creative
     "DeliveryCreative",
@@ -1042,6 +1057,7 @@ def __dir__() -> list[str]:
         AcceptProposalResponse,
         Account,
         AccountAuthorization,
+        AccountIdReference,
         AccountReference,
         AccountReferenceById,
         AccountReferenceByNaturalKey,
@@ -1185,6 +1201,7 @@ def __dir__() -> list[str]:
         CpmAuctionPricingOption,
         CpmFixedRatePricingOption,
         CpmPricingOption,
+        CpmVendorPricingOption,
         CppPricingOption,
         CpvPricingOption,
         CreateCollectionListRequest,
@@ -1220,6 +1237,7 @@ def __dir__() -> list[str]:
         CssContent,
         CssFormatAsset,
         CssFormatGroupAsset,
+        CustomVendorPricingOption,
         DaastAsset,
         DaastFormatAsset,
         DaastFormatGroupAsset,
@@ -1262,6 +1280,7 @@ def __dir__() -> list[str]:
         FeedbackSource,
         FeedFormat,
         FieldModel,
+        FlatFeeVendorPricingOption,
         FlatRatePricingOption,
         Fonts,
         ForecastableMetric,
@@ -1368,6 +1387,7 @@ def __dir__() -> list[str]:
         ImageContent,
         ImageFormatAsset,
         ImageFormatGroupAsset,
+        InlineAccountReference,
         InlineDaastAsset,
         InlineVastAsset,
         Input,
@@ -1421,6 +1441,7 @@ def __dir__() -> list[str]:
         LegacyProductFilters,
         LegacyProductFormatDeclaration,
         LegacySyncCreativesRequest,
+        LegacyUpdateMediaBuyErrorResponse,
         LegacyUpdateMediaBuyRequest,
         ListAccountsRequest,
         ListAccountsResponse,
@@ -1473,6 +1494,7 @@ def __dir__() -> list[str]:
         Metadata,
         Method,
         MetricType,
+        MissingMetric,
         ModuleType,
         NotificationAuthentication,
         NotificationConfig,
@@ -1498,8 +1520,10 @@ def __dir__() -> list[str]:
         PaginationResponse,
         Parameters,
         PaymentTerms,
+        PercentOfMediaVendorPricingOption,
         Performance,
         PerformanceFeedback,
+        PerUnitVendorPricingOption,
         PixelTrackerAsset,
         PixelTrackerEvent,
         PixelTrackerMethod,
@@ -1522,6 +1546,7 @@ def __dir__() -> list[str]:
         PricingOption,
         PrimaryCountry,
         Product,
+        ProductAllocation,
         ProductCard,
         ProductCardDetailed,
         ProductCatalog,
@@ -1612,6 +1637,8 @@ def __dir__() -> list[str]:
         Signal,
         SignalAvailabilityType,
         SignalCatalogType,
+        SignalCoverageForecast,
+        SignalCoverageRange,
         SignalDefinitionEnrichment,
         SignalFilters,
         SignalListing,
@@ -1704,6 +1731,7 @@ def __dir__() -> list[str]:
         Totals,
         TrackingEvent,
         Transform,
+        TrustedMatch,
         Unit,
         UnknownFormatAsset,
         UnknownGroupAsset,
@@ -1761,6 +1789,7 @@ def __dir__() -> list[str]:
         VcpmFixedRatePricingOption,
         VcpmPricingOption,
         VehicleUnit,
+        VendorPricingOptionUnion,
         VenueBreakdownItem,
         VerifyBrandClaimPayload,
         VerifyBrandClaimRequest,
diff --git a/src/adcp/types/_eager.py b/src/adcp/types/_eager.py
index e302e35b5..71529b0ab 100644
--- a/src/adcp/types/_eager.py
+++ b/src/adcp/types/_eager.py
@@ -452,6 +452,7 @@
 
 # Import semantic aliases for discriminated unions
 from adcp.types.aliases import (
+    AccountIdReference,
     AccountReferenceById,
     AccountReferenceByNaturalKey,
     AcquireRightsAcquiredResponse,
@@ -521,12 +522,14 @@
     CoreGovernanceAgent,
     CoreMediaBuy,
     CoreSetup,
+    CpmVendorPricingOption,
     CreateContentStandardsErrorResponse,
     CreateContentStandardsResponse1,
     CreateContentStandardsSuccessResponse,
     CreateMediaBuyAuthentication,
     CssFormatAsset,
     CssFormatGroupAsset,
+    CustomVendorPricingOption,
     DaastAsset,
     DaastFormatAsset,
     DaastFormatGroupAsset,
@@ -535,6 +538,7 @@
     Deployment,
     Destination,
     DurationUnit,
+    FlatFeeVendorPricingOption,
     FormatAssetUnion,
     GetAccountFinancialsErrorResponse,
     GetAccountFinancialsResponse1,
@@ -581,11 +585,13 @@
     IdentityMatchTmpxMacro,
     ImageFormatAsset,
     ImageFormatGroupAsset,
+    InlineAccountReference,
     InlineDaastAsset,
     InlineVastAsset,
     JavascriptFormatAsset,
     JavascriptFormatGroupAsset,
     KeyValueActivationKey,
+    LegacyUpdateMediaBuyErrorResponse,
     ListContentStandardsErrorResponse,
     ListContentStandardsResponse1,
     ListContentStandardsSuccessResponse,
@@ -602,14 +608,18 @@
     MarkdownFormatAsset,
     MarkdownFormatGroupAsset,
     MediaBuyDeliveryStatus,
+    MissingMetric,
     NotificationAuthentication,
     OverlayUnit,
+    PercentOfMediaVendorPricingOption,
+    PerUnitVendorPricingOption,
     PixelTrackerAsset,
     PixelTrackerEvent,
     PixelTrackerMethod,
     PlatformDeployment,
     PlatformDestination,
     PricingOption,
+    ProductAllocation,
     ProductFormatSellerPreference,
     PropertyId,
     PropertyTag,
@@ -631,6 +641,8 @@
     RepeatableAssetGroup,
     ReportingWebhookAuthentication,
     SegmentIdActivationKey,
+    SignalCoverageForecast,
+    SignalCoverageRange,
     SiSendActionResponseRequest,
     SiSendTextMessageRequest,
     SiSponsoredContextDeclaredBy,
@@ -667,6 +679,7 @@
     TasksListSort,
     TextFormatAsset,
     TextFormatGroupAsset,
+    TrustedMatch,
     UnknownFormatAsset,
     UnknownGroupAsset,
     UpdateContentStandardsErrorResponse,
@@ -694,6 +707,7 @@
     VastFormatGroupAsset,
     VastTrackerAsset,
     VehicleUnit,
+    VendorPricingOptionUnion,
     VideoFormatAsset,
     VideoFormatGroupAsset,
     WebhookFormatAsset,
@@ -977,9 +991,11 @@ def __init__(self, *args: object, **kwargs: object) -> None:
     "A2UiSurface",
     "Account",
     "AccountAuthorization",
+    "AccountIdReference",
     "AccountReference",
     "AccountReferenceById",
     "AccountReferenceByNaturalKey",
+    "InlineAccountReference",
     "AccountResponse",
     "AccountScope",
     "AccountWithAuthorization",
@@ -1642,6 +1658,7 @@ def __init__(self, *args: object, **kwargs: object) -> None:
     "UpdateContentStandardsSuccessResponse",
     "UpdateFrequency",
     "UpdateMediaBuyErrorResponse",
+    "LegacyUpdateMediaBuyErrorResponse",
     "UpdateMediaBuyPackagesRequest",
     "UpdateMediaBuyPropertiesRequest",
     "UpdateMediaBuyRequest",
@@ -1717,6 +1734,17 @@ def __init__(self, *args: object, **kwargs: object) -> None:
     "WholesaleFeedEvent",
     "WholesaleFeedSignal",
     "WholesaleFeedWebhook",
+    "CpmVendorPricingOption",
+    "CustomVendorPricingOption",
+    "FlatFeeVendorPricingOption",
+    "MissingMetric",
+    "PercentOfMediaVendorPricingOption",
+    "PerUnitVendorPricingOption",
+    "ProductAllocation",
+    "SignalCoverageForecast",
+    "SignalCoverageRange",
+    "TrustedMatch",
+    "VendorPricingOptionUnion",
     "aliases",
     "generated",
     "is_activate_signal_error",
diff --git a/src/adcp/types/aliases.py b/src/adcp/types/aliases.py
index 298fe450f..3945a200b 100644
--- a/src/adcp/types/aliases.py
+++ b/src/adcp/types/aliases.py
@@ -133,6 +133,31 @@
     Recovery,
     Source,
 )
+from adcp.types.generated_poc.core.missing_metric import MissingMetric
+from adcp.types.generated_poc.core.product import TrustedMatch
+from adcp.types.generated_poc.core.product_allocation import ProductAllocation
+from adcp.types.generated_poc.core.signal_coverage_forecast import SignalCoverageForecast
+from adcp.types.generated_poc.core.vendor_pricing_option import (
+    VendorPricingOption as VendorPricingOptionUnion,
+)
+from adcp.types.generated_poc.core.vendor_pricing_option import (
+    VendorPricingOption1 as CpmVendorPricingOption,
+)
+from adcp.types.generated_poc.core.vendor_pricing_option import (
+    VendorPricingOption2 as PercentOfMediaVendorPricingOption,
+)
+from adcp.types.generated_poc.core.vendor_pricing_option import (
+    VendorPricingOption3 as FlatFeeVendorPricingOption,
+)
+from adcp.types.generated_poc.core.vendor_pricing_option import (
+    VendorPricingOption4 as PerUnitVendorPricingOption,
+)
+from adcp.types.generated_poc.core.vendor_pricing_option import (
+    VendorPricingOption5 as CustomVendorPricingOption,
+)
+from adcp.types.generated_poc.signals.get_signals_response import (
+    Range as SignalCoverageRange,
+)
 from adcp.types.generated_poc.media_buy.create_media_buy_response import (
     CreateMediaBuyResponse1,
     CreateMediaBuyResponse2,
@@ -545,6 +570,12 @@ def _generated_alias(name: str, fallback_name: str) -> Any:
     ```
 """
 
+# Stable names for the former numbered codegen artifacts. These aliases are
+# intentionally synonyms of the longer pre-existing names so adopters can
+# migrate private imports without depending on generator numbering.
+AccountIdReference = AccountReference1
+InlineAccountReference = AccountReference2
+
 # ============================================================================
 # RESPONSE TYPE ALIASES - Success/Error Discriminated Unions
 # ============================================================================
@@ -781,6 +812,9 @@ def process_result(result: SyncCatalogResult) -> None:
 UpdateMediaBuyErrorResponse: TypeAlias = UpdateMediaBuyResponse2
 """Error response - media buy update failed, no changes applied."""
 
+LegacyUpdateMediaBuyErrorResponse: TypeAlias = UpdateMediaBuyResponse2
+"""Exact legacy-generated update error shape for private-import migration."""
+
 UpdateMediaBuySubmittedResponse: TypeAlias = UpdateMediaBuyResponse3
 """Submitted (async) envelope - media buy update accepted for async processing."""
 
@@ -2191,8 +2225,22 @@ class UnknownGroupAsset(_BaseGroupAsset):
     "RealEstateUnit",
     "VehicleUnit",
     # Account reference variants
+    "AccountIdReference",
+    "InlineAccountReference",
     "AccountReferenceById",
     "AccountReferenceByNaturalKey",
+    # Collision-safe SDK 8 migration surface
+    "VendorPricingOptionUnion",
+    "CpmVendorPricingOption",
+    "PercentOfMediaVendorPricingOption",
+    "FlatFeeVendorPricingOption",
+    "PerUnitVendorPricingOption",
+    "CustomVendorPricingOption",
+    "ProductAllocation",
+    "TrustedMatch",
+    "SignalCoverageForecast",
+    "SignalCoverageRange",
+    "MissingMetric",
     # Canonical-formats v2 surface (AdCP 3.1)
     "CanonicalAssetSource",
     "CanonicalCompositionModel",
@@ -2361,6 +2409,7 @@ class UnknownGroupAsset(_BaseGroupAsset):
     # Update media buy responses
     "UpdateMediaBuySuccessResponse",
     "UpdateMediaBuyErrorResponse",
+    "LegacyUpdateMediaBuyErrorResponse",
     "UpdateMediaBuyResponse3",
     "UpdateMediaBuySubmittedResponse",
     # Validate content delivery responses
diff --git a/src/adcp/types/v30.py b/src/adcp/types/v30.py
index 95ae18c56..417a643b0 100644
--- a/src/adcp/types/v30.py
+++ b/src/adcp/types/v30.py
@@ -1,4 +1,4 @@
-"""Public AdCP 3.0 request/response models."""
+"""Public AdCP 3.0 boundary models with a generated static typing stub."""
 
 from adcp.types.versioned import versioned_surface
 
diff --git a/src/adcp/types/v30.pyi b/src/adcp/types/v30.pyi
new file mode 100644
index 000000000..3b3bf3990
--- /dev/null
+++ b/src/adcp/types/v30.pyi
@@ -0,0 +1,10672 @@
+"""Generated typing surface for the dynamic version-scoped models."""
+
+from __future__ import annotations
+
+import builtins
+from typing import Any, Literal, overload
+from typing_extensions import Never, NotRequired, Required, TypedDict
+
+from adcp.types.versioned import VersionedSchemaModel
+
+# Underscored TypedDicts are private stub details used to type nested values.
+# Runtime composition remains dict-based through the public boundary models.
+
+class _ExternalCoreBrandRef(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_ExternalCoreBrandRefDataSubjectContestation]
+
+class _AcquireRightsRequestCampaign(TypedDict, total=False):
+    description: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    estimated_impressions: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+
+class _ExternalCorePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_ExternalCorePushNotificationConfigAuthentication]
+
+class _ExternalBrandRightsTerms(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+    period: NotRequired[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual', 'one_time']]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    impression_cap: NotRequired[builtins.int]
+    overage_cpm: NotRequired[builtins.float]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    exclusivity: NotRequired[_ExternalBrandRightsTermsExclusivity]
+
+class _ExternalCoreGenerationCredential(TypedDict, total=False):
+    provider: Required[builtins.str]
+    rights_key: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    expires_at: NotRequired[builtins.str]
+    endpoint: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    text: NotRequired[builtins.str]
+
+class _ExternalCoreRightsConstraint(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_ExternalCoreRightsConstraintRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_ExternalCoreErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+
+class _ActivateSignalRequestDestinationsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ActivateSignalRequestDestinationsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ActivateSignalRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ActivateSignalRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ActivateSignalResponseDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant1 | _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant1 | _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _ExternalCoreCreativeManifest(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _BuildCreativeRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _BuildCreativeRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _BuildCreativeRequestPreviewInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview(TypedDict, total=False):
+    previews: Required[builtins.list[_BuildCreativeResponsePreviewPreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _ExternalCoreCreativeConsumption(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeResponsePreview2(TypedDict, total=False):
+    previews: Required[builtins.list[_BuildCreativeResponsePreview2PreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _ExternalContentStandardsArtifact(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_ExternalContentStandardsArtifactAssetsItemVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant3 | _ExternalContentStandardsArtifactAssetsItemVariant4]]
+    metadata: NotRequired[_ExternalContentStandardsArtifactMetadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_ExternalContentStandardsArtifactIdentifiers]
+
+class _CalibrateContentResponseFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalCorePlannedDelivery(TypedDict, total=False):
+    geo: NotRequired[_ExternalCorePlannedDeliveryGeo]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    frequency_cap: NotRequired[_ExternalCoreFrequencyCap]
+    audience_summary: NotRequired[builtins.str]
+    audience_targeting: NotRequired[builtins.list[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant4]]
+    total_budget: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestDeliveryMetrics(TypedDict, total=False):
+    reporting_period: Required[_CheckGovernanceRequestDeliveryMetricsReportingPeriod]
+    spend: NotRequired[builtins.float]
+    cumulative_spend: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.int]
+    cumulative_impressions: NotRequired[builtins.int]
+    geo_distribution: NotRequired[builtins.dict[builtins.str, builtins.float]]
+    channel_distribution: NotRequired[builtins.dict[builtins.str, builtins.float]]
+    pacing: NotRequired[Literal['ahead', 'on_track', 'behind']]
+    audience_distribution: NotRequired[_CheckGovernanceRequestDeliveryMetricsAudienceDistribution]
+
+class _ExternalCoreBusinessEntity(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_ExternalCoreBusinessEntityAddress]
+    contacts: NotRequired[builtins.list[_ExternalCoreBusinessEntityContactsItem]]
+    bank: NotRequired[_ExternalCoreBusinessEntityBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceResponseFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    policy_id: NotRequired[builtins.str]
+    source_plan_id: NotRequired[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    confidence: NotRequired[builtins.float]
+    uncertainty_reason: NotRequired[builtins.str]
+
+class _CheckGovernanceResponseConditionsItem(TypedDict, total=False):
+    field: Required[builtins.str]
+    required_value: NotRequired[Any]
+    reason: Required[builtins.str]
+
+class _ComplyTestControllerRequestParams(TypedDict, total=False):
+    creative_id: NotRequired[builtins.str]
+    account_id: NotRequired[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    session_id: NotRequired[builtins.str]
+    product_id: NotRequired[builtins.str]
+    pricing_option_id: NotRequired[builtins.str]
+    plan_id: NotRequired[builtins.str]
+    fixture: NotRequired[builtins.dict[builtins.str, Any]]
+    status: NotRequired[builtins.str]
+    rejection_reason: NotRequired[builtins.str]
+    termination_reason: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    clicks: NotRequired[builtins.int]
+    conversions: NotRequired[builtins.int]
+    reported_spend: NotRequired[_ComplyTestControllerRequestParamsReportedSpend]
+    spend_percentage: NotRequired[builtins.float]
+    arm: NotRequired[Literal['submitted', 'input-required']]
+    task_id: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+    format_id: NotRequired[builtins.str]
+    result: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerResponseForced(TypedDict, total=False):
+    arm: Required[Literal['submitted', 'input-required']]
+    task_id: NotRequired[builtins.str]
+
+class _ContextMatchRequestArtifactRefsItem(TypedDict, total=False):
+    type: Required[Literal['url', 'url_hash', 'eidr', 'gracenote', 'isrc', 'gtin', 'rss_guid', 'isbn', 'custom']]
+    value: Required[builtins.str]
+
+class _ContextMatchRequestGeo(TypedDict, total=False):
+    country: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    metro: NotRequired[_ContextMatchRequestGeoMetro]
+
+class _ContextMatchRequestContextSignals(TypedDict, total=False):
+    topics: NotRequired[builtins.list[builtins.str]]
+    taxonomy_source: NotRequired[builtins.str]
+    taxonomy_id: NotRequired[builtins.int]
+    sentiment: NotRequired[Literal['positive', 'negative', 'neutral', 'mixed']]
+    keywords: NotRequired[builtins.list[builtins.str]]
+    language: NotRequired[builtins.str]
+    content_policies: NotRequired[builtins.list[builtins.str]]
+    summary: NotRequired[builtins.str]
+    embedding: NotRequired[builtins.str]
+    embedding_model: NotRequired[builtins.str]
+    embedding_dims: NotRequired[builtins.int]
+
+class _ExternalTmpOffer(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    seller_agent: NotRequired[_ExternalCoreSellerAgentRef]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    price: NotRequired[_ExternalTmpOfferPrice]
+    summary: NotRequired[builtins.str]
+    creative_manifest: NotRequired[_ExternalCoreCreativeManifest]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+
+class _ContextMatchResponseSignals(TypedDict, total=False):
+    segments: NotRequired[builtins.list[builtins.str]]
+    targeting_kvs: NotRequired[builtins.list[_ContextMatchResponseSignalsTargetingKvsItem]]
+
+class _CreateCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreateCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _ExternalCollectionCollectionListFilters(TypedDict, total=False):
+    content_ratings_exclude: NotRequired[builtins.list[_ExternalCoreContentRating]]
+    content_ratings_include: NotRequired[builtins.list[_ExternalCoreContentRating]]
+    genres_exclude: NotRequired[builtins.list[builtins.str]]
+    genres_include: NotRequired[builtins.list[builtins.str]]
+    genre_taxonomy: NotRequired[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+    kinds: NotRequired[builtins.list[Literal['series', 'publication', 'event_series', 'rotation']]]
+    exclude_distribution_ids: NotRequired[builtins.list[_ExternalCollectionCollectionListFiltersExcludeDistributionIdsItem]]
+    production_quality: NotRequired[builtins.list[Literal['professional', 'prosumer', 'ugc']]]
+
+class _ExternalCollectionCollectionList(TypedDict, total=False):
+    list_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    account: NotRequired[_ExternalCollectionCollectionListAccountVariant1 | _ExternalCollectionCollectionListAccountVariant2]
+    base_collections: NotRequired[builtins.list[_ExternalCollectionCollectionListBaseCollectionsItemVariant1 | _ExternalCollectionCollectionListBaseCollectionsItemVariant2 | _ExternalCollectionCollectionListBaseCollectionsItemVariant3]]
+    filters: NotRequired[_ExternalCollectionCollectionListFilters]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    webhook_url: NotRequired[builtins.str]
+    cache_duration_hours: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    collection_count: NotRequired[builtins.int]
+
+class _CreateContentStandardsRequestScope(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: Required[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _ExternalGovernancePolicyEntry(TypedDict, total=False):
+    policy_id: Required[builtins.str]
+    source: NotRequired[Literal['registry', 'inline']]
+    version: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    category: NotRequired[Literal['regulation', 'standard']]
+    enforcement: Required[Literal['must', 'should', 'may']]
+    requires_human_review: NotRequired[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[builtins.str]]
+    region_aliases: NotRequired[builtins.dict[builtins.str, builtins.list[builtins.str]]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    governance_domains: NotRequired[builtins.list[Literal['campaign', 'property', 'creative', 'content_standards']]]
+    effective_date: NotRequired[builtins.str]
+    sunset_date: NotRequired[builtins.str]
+    source_url: NotRequired[builtins.str]
+    source_name: NotRequired[builtins.str]
+    policy: Required[builtins.str]
+    guidance: NotRequired[builtins.str]
+    exemplars: NotRequired[_ExternalGovernancePolicyEntryExemplars]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2]]
+
+class _CreateMediaBuyRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreateMediaBuyRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreateMediaBuyRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequest(TypedDict, total=False):
+    adcp_major_version: NotRequired[builtins.int]
+    product_id: Required[builtins.str]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    budget: Required[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: Required[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    creatives: NotRequired[builtins.list[_ExternalCoreCreativeAsset]]
+    agency_estimate_number: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateMediaBuyRequestIoAcceptance(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    accepted_at: Required[builtins.str]
+    signatory: Required[builtins.str]
+    signature_id: NotRequired[builtins.str]
+
+class _ExternalCoreReportingWebhook(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: Required[_ExternalCoreReportingWebhookAuthentication]
+    reporting_frequency: Required[Literal['hourly', 'daily', 'monthly']]
+    requested_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'video_completions', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'viewability', 'engagement_rate', 'views', 'completed_views', 'leads', 'reach', 'frequency', 'grps', 'quartile_data', 'dooh_metrics', 'cost_per_click']]]
+
+class _CreateMediaBuyRequestArtifactWebhook(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: Required[_CreateMediaBuyRequestArtifactWebhookAuthentication]
+    delivery_mode: Required[Literal['realtime', 'batched']]
+    batch_frequency: NotRequired[Literal['hourly', 'daily']]
+    sampling_rate: NotRequired[builtins.float]
+
+class _ExternalCoreAccount(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_ExternalCoreAccountCreditLimit]
+    setup: NotRequired[_ExternalCoreAccountSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_ExternalCoreAccountGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_ExternalCoreAccountReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackage(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    impressions: NotRequired[builtins.float]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    format_ids_to_provide: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    optimization_goals: NotRequired[builtins.list[_ExternalCorePackageOptimizationGoalsItemVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant2]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_ExternalCorePackageCancellation]
+    agency_estimate_number: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreatePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreatePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyListFilters(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    property_types: NotRequired[builtins.list[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]]
+    feature_requirements: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    exclude_identifiers: NotRequired[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyList(TypedDict, total=False):
+    list_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    account: NotRequired[_ExternalPropertyPropertyListAccountVariant1 | _ExternalPropertyPropertyListAccountVariant2]
+    base_properties: NotRequired[builtins.list[_ExternalPropertyPropertyListBasePropertiesItemVariant1 | _ExternalPropertyPropertyListBasePropertiesItemVariant2 | _ExternalPropertyPropertyListBasePropertiesItemVariant3]]
+    filters: NotRequired[_ExternalPropertyPropertyListFilters]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    webhook_url: NotRequired[builtins.str]
+    cache_duration_hours: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    property_count: NotRequired[builtins.int]
+    pricing_options: NotRequired[builtins.list[_ExternalPropertyPropertyListPricingOptionsItemVariant1 | _ExternalPropertyPropertyListPricingOptionsItemVariant2 | _ExternalPropertyPropertyListPricingOptionsItemVariant3 | _ExternalPropertyPropertyListPricingOptionsItemVariant4 | _ExternalPropertyPropertyListPricingOptionsItemVariant5]]
+
+class _DeleteCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _DeleteCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _DeletePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _DeletePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAccountFinancialsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetAccountFinancialsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreDateRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _GetAccountFinancialsResponseAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetAccountFinancialsResponseAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAccountFinancialsResponseSpend(TypedDict, total=False):
+    total_spend: Required[builtins.float]
+    media_buy_count: NotRequired[builtins.int]
+
+class _GetAccountFinancialsResponseCredit(TypedDict, total=False):
+    credit_limit: Required[builtins.float]
+    available_credit: Required[builtins.float]
+    utilization_percent: NotRequired[builtins.float]
+
+class _GetAccountFinancialsResponseBalance(TypedDict, total=False):
+    available: Required[builtins.float]
+    last_top_up: NotRequired[_GetAccountFinancialsResponseBalanceLastTopUp]
+
+class _GetAccountFinancialsResponseInvoicesItem(TypedDict, total=False):
+    invoice_id: Required[builtins.str]
+    period: NotRequired[_ExternalCoreDateRange]
+    amount: Required[builtins.float]
+    status: Required[Literal['draft', 'issued', 'paid', 'past_due', 'void']]
+    due_date: NotRequired[builtins.str]
+    paid_date: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcp(TypedDict, total=False):
+    major_versions: Required[builtins.list[builtins.int]]
+    idempotency: Required[_GetAdcpCapabilitiesResponseAdcpIdempotencyVariant1 | _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant2]
+
+class _GetAdcpCapabilitiesResponseAccount(TypedDict, total=False):
+    require_operator_auth: NotRequired[builtins.bool]
+    authorization_endpoint: NotRequired[builtins.str]
+    supported_billing: NotRequired[builtins.list[Literal['operator', 'agent', 'advertiser']]]
+    required_for_products: NotRequired[builtins.bool]
+    account_financials: NotRequired[builtins.bool]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuy(TypedDict, total=False):
+    supported_pricing_models: NotRequired[builtins.list[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]]
+    reporting_delivery_methods: NotRequired[builtins.list[Literal['webhook', 'offline']]]
+    offline_delivery_protocols: NotRequired[builtins.list[Literal['s3', 'gcs', 'azure_blob']]]
+    features: NotRequired[_ExternalCoreMediaBuyFeatures]
+    execution: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecution]
+    audience_targeting: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceTargeting]
+    conversion_tracking: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyConversionTracking]
+    content_standards: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyContentStandards]
+    portfolio: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyPortfolio]
+
+class _GetAdcpCapabilitiesResponseSignals(TypedDict, total=False):
+    data_provider_domains: NotRequired[builtins.list[builtins.str]]
+    features: NotRequired[_GetAdcpCapabilitiesResponseSignalsFeatures]
+
+class _GetAdcpCapabilitiesResponseGovernance(TypedDict, total=False):
+    aggregation_window_days: NotRequired[builtins.int]
+    property_features: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItem]]
+    creative_features: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItem]]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligence(TypedDict, total=False):
+    endpoint: Required[_GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpoint]
+    capabilities: Required[_ExternalSponsoredIntelligenceSiCapabilities]
+    brand_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseBrand(TypedDict, total=False):
+    rights: NotRequired[builtins.bool]
+    right_types: NotRequired[builtins.list[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]]
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    generation_providers: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseCreative(TypedDict, total=False):
+    supports_compliance: NotRequired[builtins.bool]
+    has_creative_library: NotRequired[builtins.bool]
+    supports_generation: NotRequired[builtins.bool]
+    supports_transformation: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseRequestSigning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    covers_content_digest: NotRequired[Literal['required', 'forbidden', 'either']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    warn_for: NotRequired[builtins.list[builtins.str]]
+    supported_for: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseWebhookSigning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    profile: NotRequired[Literal['adcp/webhook-signing/v1']]
+    algorithms: NotRequired[builtins.list[Literal['ed25519', 'ecdsa-p256-sha256']]]
+    legacy_hmac_fallback: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseIdentity(TypedDict, total=False):
+    per_principal_key_isolation: NotRequired[builtins.bool]
+    key_origins: NotRequired[_GetAdcpCapabilitiesResponseIdentityKeyOrigins]
+    compromise_notification: NotRequired[_GetAdcpCapabilitiesResponseIdentityCompromiseNotification]
+
+class _GetAdcpCapabilitiesResponseComplianceTesting(TypedDict, total=False):
+    scenarios: Required[builtins.list[Literal['force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend']]]
+
+class _GetBrandIdentityResponseHouse(TypedDict, total=False):
+    domain: Required[builtins.str]
+    name: Required[builtins.str]
+
+class _GetBrandIdentityResponseLogosItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    orientation: NotRequired[Literal['square', 'horizontal', 'vertical', 'stacked']]
+    background: NotRequired[Literal['dark-bg', 'light-bg', 'transparent-bg']]
+    variant: NotRequired[Literal['primary', 'secondary', 'icon', 'wordmark', 'full-lockup']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    usage: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+
+class _GetBrandIdentityResponseColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str | builtins.list[builtins.str]]
+    secondary: NotRequired[builtins.str | builtins.list[builtins.str]]
+    accent: NotRequired[builtins.str | builtins.list[builtins.str]]
+    background: NotRequired[builtins.str | builtins.list[builtins.str]]
+    text: NotRequired[builtins.str | builtins.list[builtins.str]]
+
+class _GetBrandIdentityResponseFonts(TypedDict, total=False):
+    primary: NotRequired[builtins.str | _FontRoleVariant2]
+    secondary: NotRequired[builtins.str | _FontRoleVariant2]
+
+class _GetBrandIdentityResponseTone(TypedDict, total=False):
+    voice: NotRequired[builtins.str]
+    attributes: NotRequired[builtins.list[builtins.str]]
+    dos: NotRequired[builtins.list[builtins.str]]
+    donts: NotRequired[builtins.list[builtins.str]]
+
+class _GetBrandIdentityResponseVoiceSynthesis(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    voice_id: NotRequired[builtins.str]
+    settings: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetBrandIdentityResponseAssetsItem(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog']]
+    url: Required[builtins.str]
+    tags: NotRequired[builtins.list[builtins.str]]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+    file_size_bytes: NotRequired[builtins.int]
+    format: NotRequired[builtins.str]
+
+class _GetBrandIdentityResponseRights(TypedDict, total=False):
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    exclusivity_model: NotRequired[builtins.str]
+    content_restrictions: NotRequired[builtins.list[builtins.str]]
+
+class _GetCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetCollectionListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetCollectionListResponseCollectionsItem(TypedDict, total=False):
+    collection_rid: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    distribution_ids: NotRequired[builtins.list[_GetCollectionListResponseCollectionsItemDistributionIdsItem]]
+    content_rating: NotRequired[_ExternalCoreContentRating]
+    genre: NotRequired[builtins.list[builtins.str]]
+    genre_taxonomy: NotRequired[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+    kind: NotRequired[Literal['series', 'publication', 'event_series', 'rotation']]
+
+class _ExternalCorePaginationResponse(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _GetCollectionListResponseCoverageGapsValueItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _GetContentStandardsResponseCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_GetContentStandardsResponsePricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCreativeDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCorePaginationRequest(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+    timezone: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    totals: NotRequired[_ExternalCoreDeliveryMetrics]
+    variant_count: NotRequired[builtins.int]
+    variants: Required[builtins.list[_ExternalCoreCreativeVariant]]
+
+class _GetCreativeDeliveryResponsePagination(TypedDict, total=False):
+    limit: Required[builtins.int]
+    offset: Required[builtins.int]
+    has_more: Required[builtins.bool]
+    total: NotRequired[builtins.int]
+
+class _GetCreativeFeaturesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCreativeCreativeFeatureResult(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    value: Required[builtins.bool | builtins.float | builtins.str]
+    unit: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+    measured_at: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    methodology_version: NotRequired[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    policy_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuyArtifactsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuyArtifactsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuyArtifactsRequestTimeRange(TypedDict, total=False):
+    start: NotRequired[builtins.str]
+    end: NotRequired[builtins.str]
+
+class _GetMediaBuyArtifactsRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetMediaBuyArtifactsResponseArtifactsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    artifact: Required[_ExternalContentStandardsArtifact]
+    country: NotRequired[builtins.str]
+    channel: NotRequired[builtins.str]
+    brand_context: NotRequired[_GetMediaBuyArtifactsResponseArtifactsItemBrandContext]
+    local_verdict: NotRequired[Literal['pass', 'fail', 'unevaluated']]
+
+class _GetMediaBuyArtifactsResponseCollectionInfo(TypedDict, total=False):
+    total_deliveries: NotRequired[builtins.int]
+    total_collected: NotRequired[builtins.int]
+    returned_count: NotRequired[builtins.int]
+    effective_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuyDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuyDeliveryRequestAttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_GetMediaBuyDeliveryRequestAttributionWindowPostClick]
+    post_view: NotRequired[_GetMediaBuyDeliveryRequestAttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensions(TypedDict, total=False):
+    geo: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsGeo]
+    device_type: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDeviceType]
+    device_platform: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDevicePlatform]
+    audience: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsAudience]
+    placement: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsPlacement]
+
+class _GetMediaBuyDeliveryResponseReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalCoreAttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCoreAttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCoreAttributionWindowPostView]
+    model: Required[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotals(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    media_buy_count: Required[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem(TypedDict, total=False):
+    media_buy_id: Required[builtins.str]
+    status: Required[Literal['pending_creatives', 'pending_start', 'pending', 'active', 'paused', 'completed', 'rejected', 'canceled', 'failed', 'reporting_delayed']]
+    expected_availability: NotRequired[builtins.str]
+    is_adjusted: NotRequired[builtins.bool]
+    pricing_model: NotRequired[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    totals: Required[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotals]
+    by_package: Required[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItem]]
+    daily_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemDailyBreakdownItem]]
+
+class _GetMediaBuysRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuysRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItem(TypedDict, total=False):
+    media_buy_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    invoice_recipient: NotRequired[_ExternalCoreBusinessEntity]
+    status: Required[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]
+    currency: Required[builtins.str]
+    total_budget: Required[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    confirmed_at: NotRequired[builtins.str]
+    cancellation: NotRequired[_GetMediaBuysResponseMediaBuysItemCancellation]
+    revision: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    valid_actions: NotRequired[builtins.list[Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_packages', 'sync_creatives']]]
+    history: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemHistoryItem]]
+    packages: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    plan_version: Required[builtins.int]
+    status: Required[Literal['active', 'suspended', 'completed']]
+    budget: Required[_GetPlanAuditLogsResponsePlansItemBudget]
+    channel_allocation: NotRequired[builtins.dict[builtins.str, _GetPlanAuditLogsResponsePlansItemChannelAllocationValue]]
+    summary: Required[_GetPlanAuditLogsResponsePlansItemSummary]
+    entries: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItem]]
+    governed_actions: Required[builtins.list[_GetPlanAuditLogsResponsePlansItemGovernedActionsItem]]
+
+class _ExternalCoreProduct(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    publisher_properties: Required[builtins.list[_ExternalCoreProductPublisherPropertiesItemVariant1 | _ExternalCoreProductPublisherPropertiesItemVariant2 | _ExternalCoreProductPublisherPropertiesItemVariant3]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    format_ids: Required[builtins.list[_ExternalCoreFormatId]]
+    placements: NotRequired[builtins.list[_ExternalCorePlacement]]
+    delivery_type: Required[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    pricing_options: Required[builtins.list[_ExternalCoreProductPricingOptionsItemVariant1 | _ExternalCoreProductPricingOptionsItemVariant2 | _ExternalCoreProductPricingOptionsItemVariant3 | _ExternalCoreProductPricingOptionsItemVariant4 | _ExternalCoreProductPricingOptionsItemVariant5 | _ExternalCoreProductPricingOptionsItemVariant6 | _ExternalCoreProductPricingOptionsItemVariant7 | _ExternalCoreProductPricingOptionsItemVariant8 | _ExternalCoreProductPricingOptionsItemVariant9]]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    outcome_measurement: NotRequired[_ExternalCoreOutcomeMeasurement]
+    delivery_measurement: NotRequired[_ExternalCoreProductDeliveryMeasurement]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    cancellation_policy: NotRequired[_ExternalCoreCancellationPolicy]
+    reporting_capabilities: Required[_ExternalCoreReportingCapabilities]
+    creative_policy: NotRequired[_ExternalCoreCreativePolicy]
+    is_custom: NotRequired[builtins.bool]
+    property_targeting_allowed: NotRequired[builtins.bool]
+    data_provider_signals: NotRequired[builtins.list[_ExternalCoreProductDataProviderSignalsItemVariant1 | _ExternalCoreProductDataProviderSignalsItemVariant2 | _ExternalCoreProductDataProviderSignalsItemVariant3]]
+    signal_targeting_allowed: NotRequired[builtins.bool]
+    catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    metric_optimization: NotRequired[_ExternalCoreProductMetricOptimization]
+    max_optimization_goals: NotRequired[builtins.int]
+    measurement_readiness: NotRequired[_ExternalCoreMeasurementReadiness]
+    conversion_tracking: NotRequired[_ExternalCoreProductConversionTracking]
+    catalog_match: NotRequired[_ExternalCoreProductCatalogMatch]
+    brief_relevance: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    product_card: NotRequired[_ExternalCoreProductProductCard]
+    product_card_detailed: NotRequired[_ExternalCoreProductProductCardDetailed]
+    collections: NotRequired[builtins.list[_ExternalCoreCollectionSelector]]
+    collection_targeting_allowed: NotRequired[builtins.bool]
+    installments: NotRequired[builtins.list[_ExternalCoreInstallment]]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_ExternalCoreProductTrustedMatch]
+    material_submission: NotRequired[_ExternalCoreProductMaterialSubmission]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetProductsRequestRefineItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    ask: Required[builtins.str]
+
+class _GetProductsRequestRefineItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    action: NotRequired[Literal['include', 'omit', 'more_like_this']]
+    ask: NotRequired[builtins.str]
+
+class _GetProductsRequestRefineItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    action: NotRequired[Literal['include', 'omit', 'finalize']]
+    ask: NotRequired[builtins.str]
+
+class _ExternalCoreCatalog(TypedDict, total=False):
+    catalog_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    url: NotRequired[builtins.str]
+    feed_format: NotRequired[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'custom']]
+    update_frequency: NotRequired[Literal['realtime', 'hourly', 'daily', 'weekly']]
+    items: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    ids: NotRequired[builtins.list[builtins.str]]
+    gtins: NotRequired[builtins.list[builtins.str]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    category: NotRequired[builtins.str]
+    query: NotRequired[builtins.str]
+    conversion_events: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+    feed_field_mappings: NotRequired[builtins.list[_ExternalCoreCatalogFieldMapping]]
+
+class _GetProductsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetProductsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFilters(TypedDict, total=False):
+    delivery_type: NotRequired[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    is_fixed_price: NotRequired[builtins.bool]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    standard_formats_only: NotRequired[builtins.bool]
+    min_exposures: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    budget_range: NotRequired[_ExternalCoreProductFiltersBudgetRange]
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+    metros: NotRequired[builtins.list[_ExternalCoreProductFiltersMetrosItem]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    required_axe_integrations: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_ExternalCoreProductFiltersTrustedMatch]
+    required_features: NotRequired[_ExternalCoreMediaBuyFeatures]
+    required_geo_targeting: NotRequired[builtins.list[_ExternalCoreProductFiltersRequiredGeoTargetingItem]]
+    signal_targeting: NotRequired[builtins.list[_ExternalCoreProductFiltersSignalTargetingItemVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant3]]
+    postal_areas: NotRequired[builtins.list[_ExternalCoreProductFiltersPostalAreasItem]]
+    geo_proximity: NotRequired[builtins.list[_ExternalCoreProductFiltersGeoProximityItemVariant1 | _ExternalCoreProductFiltersGeoProximityItemVariant2 | _ExternalCoreProductFiltersGeoProximityItemVariant3]]
+    required_performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    keywords: NotRequired[builtins.list[_ExternalCoreProductFiltersKeywordsItem]]
+
+class _ExternalCorePropertyListRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _GetProductsRequestTimeBudget(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    allocations: Required[builtins.list[_ExternalCoreProductAllocation]]
+    proposal_status: NotRequired[Literal['draft', 'committed']]
+    expires_at: NotRequired[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+    total_budget_guidance: NotRequired[_ExternalCoreProposalTotalBudgetGuidance]
+    brief_alignment: NotRequired[builtins.str]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetProductsResponseRefinementAppliedItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseRefinementAppliedItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseRefinementAppliedItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseIncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['products', 'pricing', 'forecast', 'proposals']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_GetProductsResponseIncompleteItemEstimatedWait]
+
+class _GetPropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetPropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetPropertyListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _ExternalCoreIdentifier(TypedDict, total=False):
+    type: Required[Literal['domain', 'subdomain', 'network_id', 'ios_bundle', 'android_package', 'apple_app_store_id', 'google_play_id', 'roku_store_id', 'fire_tv_asin', 'samsung_app_id', 'apple_tv_bundle', 'bundle_id', 'venue_id', 'screen_id', 'openooh_venue_type', 'rss_url', 'apple_podcast_id', 'spotify_collection_id', 'podcast_guid', 'station_id', 'facility_id']]
+    value: Required[builtins.str]
+
+class _GetRightsResponseRightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    brand_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    match_score: NotRequired[builtins.float]
+    match_reasons: NotRequired[builtins.list[builtins.str]]
+    available_uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    exclusivity_status: NotRequired[_GetRightsResponseRightsItemExclusivityStatus]
+    pricing_options: Required[builtins.list[_ExternalBrandRightsPricingOption]]
+    content_restrictions: NotRequired[builtins.list[builtins.str]]
+    preview_assets: NotRequired[builtins.list[_GetRightsResponseRightsItemPreviewAssetsItem]]
+
+class _GetRightsResponseExcludedItem(TypedDict, total=False):
+    brand_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    reason: Required[builtins.str]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetSignalsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetSignalsRequestSignalIdsItemVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsRequestSignalIdsItemVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsRequestDestinationsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _GetSignalsRequestDestinationsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ExternalCoreSignalFilters(TypedDict, total=False):
+    catalog_types: NotRequired[builtins.list[Literal['marketplace', 'custom', 'owned']]]
+    data_providers: NotRequired[builtins.list[builtins.str]]
+    max_cpm: NotRequired[builtins.float]
+    max_percent: NotRequired[builtins.float]
+    min_coverage_percentage: NotRequired[builtins.float]
+
+class _GetSignalsResponseSignalsItem(TypedDict, total=False):
+    signal_id: Required[_GetSignalsResponseSignalsItemSignalIdVariant1 | _GetSignalsResponseSignalsItemSignalIdVariant2]
+    signal_agent_segment_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_GetSignalsResponseSignalsItemRange]
+    signal_type: Required[Literal['marketplace', 'custom', 'owned']]
+    data_provider: Required[builtins.str]
+    coverage_percentage: Required[builtins.float]
+    deployments: Required[builtins.list[_GetSignalsResponseSignalsItemDeploymentsItemVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant2]]
+    pricing_options: Required[builtins.list[_GetSignalsResponseSignalsItemPricingOptionsItemVariant1 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant2 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant3 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant4 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant5]]
+
+class _IdentityMatchRequestIdentitiesItem(TypedDict, total=False):
+    user_token: Required[builtins.str]
+    uid_type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'other']]
+
+class _IdentityMatchRequestConsent(TypedDict, total=False):
+    gdpr: NotRequired[builtins.bool]
+    tcf_consent: NotRequired[builtins.str]
+    gpp: NotRequired[builtins.str]
+    us_privacy: NotRequired[builtins.str]
+
+class _ListCollectionListsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCollectionListsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalContentStandardsContentStandards(TypedDict, total=False):
+    standards_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: NotRequired[builtins.list[builtins.str]]
+    policies: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+    calibration_exemplars: NotRequired[_ExternalContentStandardsContentStandardsCalibrationExemplars]
+    pricing_options: NotRequired[builtins.list[_ExternalContentStandardsContentStandardsPricingOptionsItemVariant1 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant2 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant3 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant4 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativeFormatsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCreativeFormatsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreFormat(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    example_url: NotRequired[builtins.str]
+    accepts_parameters: NotRequired[builtins.list[Literal['dimensions', 'duration']]]
+    renders: NotRequired[builtins.list[_ExternalCoreFormatRendersItemVariant1 | _ExternalCoreFormatRendersItemVariant2]]
+    assets: NotRequired[builtins.list[_ExternalCoreFormatAssetsItemVariant1 | _ExternalCoreFormatAssetsItemVariant2 | _ExternalCoreFormatAssetsItemVariant3 | _ExternalCoreFormatAssetsItemVariant4 | _ExternalCoreFormatAssetsItemVariant5 | _ExternalCoreFormatAssetsItemVariant6 | _ExternalCoreFormatAssetsItemVariant7 | _ExternalCoreFormatAssetsItemVariant8 | _ExternalCoreFormatAssetsItemVariant9 | _ExternalCoreFormatAssetsItemVariant10 | _ExternalCoreFormatAssetsItemVariant11 | _ExternalCoreFormatAssetsItemVariant12 | _ExternalCoreFormatAssetsItemVariant13 | _ExternalCoreFormatAssetsItemVariant14 | _ExternalCoreFormatAssetsItemVariant15]]
+    delivery: NotRequired[builtins.dict[builtins.str, Any]]
+    supported_macros: NotRequired[builtins.list[Literal['MEDIA_BUY_ID', 'PACKAGE_ID', 'CREATIVE_ID', 'CACHEBUSTER', 'TIMESTAMP', 'CLICK_URL', 'GDPR', 'GDPR_CONSENT', 'US_PRIVACY', 'GPP_STRING', 'GPP_SID', 'IP_ADDRESS', 'LIMIT_AD_TRACKING', 'DEVICE_TYPE', 'OS', 'OS_VERSION', 'DEVICE_MAKE', 'DEVICE_MODEL', 'USER_AGENT', 'APP_BUNDLE', 'APP_NAME', 'COUNTRY', 'REGION', 'CITY', 'ZIP', 'DMA', 'LAT', 'LONG', 'DEVICE_ID', 'DEVICE_ID_TYPE', 'DOMAIN', 'PAGE_URL', 'REFERRER', 'KEYWORDS', 'PLACEMENT_ID', 'FOLD_POSITION', 'AD_WIDTH', 'AD_HEIGHT', 'VIDEO_ID', 'VIDEO_TITLE', 'VIDEO_DURATION', 'VIDEO_CATEGORY', 'CONTENT_GENRE', 'CONTENT_RATING', 'PLAYER_WIDTH', 'PLAYER_HEIGHT', 'POD_POSITION', 'POD_SIZE', 'AD_BREAK_ID', 'STATION_ID', 'COLLECTION_NAME', 'INSTALLMENT_ID', 'AUDIO_DURATION', 'TMPX', 'AXEM', 'CATALOG_ID', 'SKU', 'GTIN', 'OFFERING_ID', 'JOB_ID', 'HOTEL_ID', 'FLIGHT_ID', 'VEHICLE_ID', 'LISTING_ID', 'STORE_ID', 'PROGRAM_ID', 'DESTINATION_ID', 'CREATIVE_VARIANT_ID', 'APP_ITEM_ID'] | builtins.str]]
+    input_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_card: NotRequired[_ExternalCoreFormatFormatCard]
+    accessibility: NotRequired[_ExternalCoreFormatAccessibility]
+    supported_disclosure_positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    disclosure_capabilities: NotRequired[builtins.list[_ExternalCoreFormatDisclosureCapabilitiesItem]]
+    format_card_detailed: NotRequired[_ExternalCoreFormatFormatCardDetailed]
+    reported_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'video_completions', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'viewability', 'engagement_rate', 'views', 'completed_views', 'leads', 'reach', 'frequency', 'grps', 'quartile_data', 'dooh_metrics', 'cost_per_click']]]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreFormatPricingOptionsItemVariant1 | _ExternalCoreFormatPricingOptionsItemVariant2 | _ExternalCoreFormatPricingOptionsItemVariant3 | _ExternalCoreFormatPricingOptionsItemVariant4 | _ExternalCoreFormatPricingOptionsItemVariant5]]
+
+class _ListCreativeFormatsResponseCreativeAgentsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    agent_name: NotRequired[builtins.str]
+    capabilities: NotRequired[builtins.list[Literal['validation', 'assembly', 'generation', 'preview', 'delivery']]]
+
+class _ExternalCoreCreativeFilters(TypedDict, total=False):
+    accounts: NotRequired[builtins.list[_ExternalCoreCreativeFiltersAccountsItemVariant1 | _ExternalCoreCreativeFiltersAccountsItemVariant2]]
+    statuses: NotRequired[builtins.list[Literal['processing', 'pending_review', 'approved', 'rejected', 'archived']]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    tags_any: NotRequired[builtins.list[builtins.str]]
+    name_contains: NotRequired[builtins.str]
+    creative_ids: NotRequired[builtins.list[builtins.str]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    assigned_to_packages: NotRequired[builtins.list[builtins.str]]
+    media_buy_ids: NotRequired[builtins.list[builtins.str]]
+    unassigned: NotRequired[builtins.bool]
+    has_served: NotRequired[builtins.bool]
+    concept_ids: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    has_variables: NotRequired[builtins.bool]
+
+class _ListCreativesRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_date', 'updated_date', 'name', 'status', 'assignment_count']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListCreativesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCreativesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListCreativesResponseQuerySummary(TypedDict, total=False):
+    total_matching: Required[builtins.int]
+    returned: Required[builtins.int]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_ListCreativesResponseQuerySummarySortApplied]
+
+class _ListCreativesResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    status: Required[Literal['processing', 'pending_review', 'approved', 'rejected', 'archived']]
+    created_date: Required[builtins.str]
+    updated_date: Required[builtins.str]
+    assets: NotRequired[builtins.dict[builtins.str, Any]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    concept_id: NotRequired[builtins.str]
+    concept_name: NotRequired[builtins.str]
+    variables: NotRequired[builtins.list[_ExternalCoreCreativeVariable]]
+    assignments: NotRequired[_ListCreativesResponseCreativesItemAssignments]
+    snapshot: NotRequired[_ListCreativesResponseCreativesItemSnapshot]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    items: NotRequired[builtins.list[_ListCreativesResponseCreativesItemItemsItemVariant1 | _ListCreativesResponseCreativesItemItemsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_ListCreativesResponseCreativesItemPricingOptionsItemVariant1 | _ListCreativesResponseCreativesItemPricingOptionsItemVariant2 | _ListCreativesResponseCreativesItemPricingOptionsItemVariant3 | _ListCreativesResponseCreativesItemPricingOptionsItemVariant4 | _ListCreativesResponseCreativesItemPricingOptionsItemVariant5]]
+
+class _ListCreativesResponseStatusSummary(TypedDict, total=False):
+    processing: NotRequired[builtins.int]
+    approved: NotRequired[builtins.int]
+    pending_review: NotRequired[builtins.int]
+    rejected: NotRequired[builtins.int]
+    archived: NotRequired[builtins.int]
+
+class _ListPropertyListsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListPropertyListsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreEvent(TypedDict, total=False):
+    event_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_time: Required[builtins.str]
+    user_match: NotRequired[_ExternalCoreUserMatch]
+    custom_data: NotRequired[_ExternalCoreEventCustomData]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_url: NotRequired[builtins.str]
+    custom_event_name: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _LogEventResponsePartialFailuresItem(TypedDict, total=False):
+    event_id: Required[builtins.str]
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+
+class _PackageRequestOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_PackageRequestOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant1TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _PackageRequestOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_PackageRequestOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant2TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant2TargetVariant2 | _PackageRequestOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreTargeting(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.list[builtins.str]]
+    geo_countries_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_regions: NotRequired[builtins.list[builtins.str]]
+    geo_regions_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_metros: NotRequired[builtins.list[_ExternalCoreTargetingGeoMetrosItem]]
+    geo_metros_exclude: NotRequired[builtins.list[_ExternalCoreTargetingGeoMetrosExcludeItem]]
+    geo_postal_areas: NotRequired[builtins.list[_ExternalCoreTargetingGeoPostalAreasItem]]
+    geo_postal_areas_exclude: NotRequired[builtins.list[_ExternalCoreTargetingGeoPostalAreasExcludeItem]]
+    daypart_targets: NotRequired[builtins.list[_ExternalCoreDaypartTarget]]
+    axe_include_segment: NotRequired[builtins.str]
+    axe_exclude_segment: NotRequired[builtins.str]
+    audience_include: NotRequired[builtins.list[builtins.str]]
+    audience_exclude: NotRequired[builtins.list[builtins.str]]
+    frequency_cap: NotRequired[_ExternalCoreFrequencyCap]
+    property_list: NotRequired[_ExternalCorePropertyListRef]
+    collection_list: NotRequired[_ExternalCoreCollectionListRef]
+    collection_list_exclude: NotRequired[_ExternalCoreCollectionListRef]
+    age_restriction: NotRequired[_ExternalCoreTargetingAgeRestriction]
+    device_platform: NotRequired[builtins.list[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]]
+    device_type: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    device_type_exclude: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    store_catchments: NotRequired[builtins.list[_ExternalCoreTargetingStoreCatchmentsItem]]
+    geo_proximity: NotRequired[builtins.list[_ExternalCoreTargetingGeoProximityItemVariant1 | _ExternalCoreTargetingGeoProximityItemVariant2 | _ExternalCoreTargetingGeoProximityItemVariant3]]
+    language: NotRequired[builtins.list[builtins.str]]
+    keyword_targets: NotRequired[builtins.list[_ExternalCoreTargetingKeywordTargetsItem]]
+    negative_keywords: NotRequired[builtins.list[_ExternalCoreTargetingNegativeKeywordsItem]]
+
+class _ExternalCoreMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_ExternalCoreMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_ExternalCoreMeasurementTermsMakegoodPolicy]
+
+class _ExternalCorePerformanceStandard(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_ExternalCoreBrandRef]
+
+class _ExternalCoreCreativeAssignment(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreCreativeAsset(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalCoreCreativeAssetInputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _PreviewCreativeRequestInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeRequestRequestsItem(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    creative_manifest: Required[_ExternalCoreCreativeManifest]
+    inputs: NotRequired[builtins.list[_PreviewCreativeRequestRequestsItemInputsItem]]
+    template_id: NotRequired[builtins.str]
+    quality: NotRequired[Literal['draft', 'production']]
+    output_format: NotRequired[Literal['url', 'html']]
+    item_limit: NotRequired[builtins.int]
+
+class _PreviewCreativeResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponsePreviewsItemInput]
+
+class _PreviewCreativeResponseResultsItemVariant1(TypedDict, total=False):
+    success: Required[Literal[True]]
+    creative_id: Required[builtins.str]
+    response: Required[_PreviewCreativeResponseResultsItemVariant1Response]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _PreviewCreativeResponseResultsItemVariant2(TypedDict, total=False):
+    success: Required[Literal[False]]
+    creative_id: Required[builtins.str]
+    response: NotRequired[_PreviewCreativeResponseResultsItemVariant2Response]
+    errors: Required[builtins.list[_ExternalCoreError]]
+
+class _PreviewCreativeResponsePreviewsItem2(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1 | _PreviewCreativeResponsePreviewsItem2RendersItemVariant2 | _PreviewCreativeResponsePreviewsItem2RendersItemVariant3]]
+
+class _ExternalCoreDatetimeRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ReportPlanOutcomeRequestSellerResponse(TypedDict, total=False):
+    seller_reference: NotRequired[builtins.str]
+    committed_budget: NotRequired[builtins.float]
+    packages: NotRequired[builtins.list[_ReportPlanOutcomeRequestSellerResponsePackagesItem]]
+    planned_delivery: NotRequired[_ExternalCorePlannedDelivery]
+    creative_deadline: NotRequired[builtins.str]
+
+class _ReportPlanOutcomeRequestDelivery(TypedDict, total=False):
+    reporting_period: NotRequired[_ReportPlanOutcomeRequestDeliveryReportingPeriod]
+    impressions: NotRequired[builtins.int]
+    spend: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    viewability_rate: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+
+class _ReportPlanOutcomeRequestError(TypedDict, total=False):
+    code: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+
+class _ReportPlanOutcomeResponseFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ReportPlanOutcomeResponsePlanSummary(TypedDict, total=False):
+    total_committed: NotRequired[builtins.float]
+    budget_remaining: NotRequired[builtins.float]
+
+class _ReportUsageRequestUsageItem(TypedDict, total=False):
+    account: Required[_ReportUsageRequestUsageItemAccountVariant1 | _ReportUsageRequestUsageItemAccountVariant2]
+    media_buy_id: NotRequired[builtins.str]
+    vendor_cost: Required[builtins.float]
+    currency: Required[builtins.str]
+    pricing_option_id: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    media_spend: NotRequired[builtins.float]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    standards_id: NotRequired[builtins.str]
+    rights_id: NotRequired[builtins.str]
+    creative_id: NotRequired[builtins.str]
+    property_list_id: NotRequired[builtins.str]
+
+class _SiGetOfferingResponseOffering(TypedDict, total=False):
+    offering_id: NotRequired[builtins.str]
+    title: NotRequired[builtins.str]
+    summary: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    price_hint: NotRequired[builtins.str]
+    image_url: NotRequired[builtins.str]
+    landing_url: NotRequired[builtins.str]
+
+class _SiGetOfferingResponseMatchingProductsItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    price: NotRequired[builtins.str]
+    original_price: NotRequired[builtins.str]
+    image_url: NotRequired[builtins.str]
+    availability_summary: NotRequired[builtins.str]
+    url: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentity(TypedDict, total=False):
+    consent_granted: Required[builtins.bool]
+    consent_timestamp: NotRequired[builtins.str]
+    consent_scope: NotRequired[builtins.list[Literal['name', 'email', 'shipping_address', 'phone', 'locale']]]
+    privacy_policy_acknowledged: NotRequired[_ExternalSponsoredIntelligenceSiIdentityPrivacyPolicyAcknowledged]
+    user: NotRequired[_ExternalSponsoredIntelligenceSiIdentityUser]
+    anonymous_session_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilities(TypedDict, total=False):
+    modalities: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesModalities]
+    components: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesComponents]
+    commerce: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesCommerce]
+    a2ui: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesA2ui]
+    mcp_apps: NotRequired[builtins.bool]
+
+class _SiInitiateSessionResponseResponse(TypedDict, total=False):
+    message: NotRequired[builtins.str]
+    ui_elements: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiUiElement]]
+
+class _SiSendMessageRequestActionResponse(TypedDict, total=False):
+    action: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiSendMessageResponseResponse(TypedDict, total=False):
+    message: NotRequired[builtins.str]
+    surface: NotRequired[_ExternalA2uiSurface]
+    ui_elements: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiUiElement]]
+
+class _SiSendMessageResponseHandoff(TypedDict, total=False):
+    type: NotRequired[Literal['transaction', 'complete']]
+    intent: NotRequired[_SiSendMessageResponseHandoffIntent]
+    context_for_checkout: NotRequired[_SiSendMessageResponseHandoffContextForCheckout]
+
+class _SiTerminateSessionRequestTerminationContext(TypedDict, total=False):
+    summary: NotRequired[builtins.str]
+    transaction_intent: NotRequired[_SiTerminateSessionRequestTerminationContextTransactionIntent]
+    cause: NotRequired[builtins.str]
+
+class _SiTerminateSessionResponseAcpHandoff(TypedDict, total=False):
+    checkout_url: NotRequired[builtins.str]
+    checkout_token: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    expires_at: NotRequired[builtins.str]
+
+class _SiTerminateSessionResponseFollowUp(TypedDict, total=False):
+    action: NotRequired[Literal['save_for_later', 'set_reminder', 'subscribe_updates', 'none']]
+    data: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsRequestAccountsItem(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    billing: Required[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    sandbox: NotRequired[builtins.bool]
+    preferred_reporting_protocol: NotRequired[Literal['s3', 'gcs', 'azure_blob']]
+
+class _SyncAccountsResponseAccountsItem(TypedDict, total=False):
+    account_id: NotRequired[builtins.str]
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed']]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    setup: NotRequired[_SyncAccountsResponseAccountsItemSetup]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_SyncAccountsResponseAccountsItemCreditLimit]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAudiencesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAudiencesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAudiencesRequestAudiencesItem(TypedDict, total=False):
+    audience_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    audience_type: NotRequired[Literal['crm', 'suppression', 'lookalike_seed']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    add: NotRequired[builtins.list[_ExternalCoreAudienceMember]]
+    remove: NotRequired[builtins.list[_ExternalCoreAudienceMember]]
+    delete: NotRequired[builtins.bool]
+    consent_basis: NotRequired[Literal['consent', 'legitimate_interest', 'contract', 'legal_obligation']]
+
+class _SyncAudiencesResponseAudiencesItem(TypedDict, total=False):
+    audience_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    seller_id: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'deleted', 'failed']]
+    status: NotRequired[Literal['processing', 'ready', 'too_small']]
+    uploaded_count: NotRequired[builtins.int]
+    total_uploaded_count: NotRequired[builtins.int]
+    matched_count: NotRequired[builtins.int]
+    effective_match_rate: NotRequired[builtins.float]
+    match_breakdown: NotRequired[builtins.list[_SyncAudiencesResponseAudiencesItemMatchBreakdownItem]]
+    last_synced_at: NotRequired[builtins.str]
+    minimum_size: NotRequired[builtins.int]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncCatalogsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncCatalogsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncCatalogsResponseCatalogsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    platform_id: NotRequired[builtins.str]
+    item_count: NotRequired[builtins.int]
+    items_approved: NotRequired[builtins.int]
+    items_pending: NotRequired[builtins.int]
+    items_rejected: NotRequired[builtins.int]
+    item_issues: NotRequired[builtins.list[_SyncCatalogsResponseCatalogsItemItemIssuesItem]]
+    last_synced_at: NotRequired[builtins.str]
+    next_fetch_at: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncCreativesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncCreativesRequestAssignmentsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'rejected', 'archived']]
+    platform_id: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    preview_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    assigned_to: NotRequired[builtins.list[builtins.str]]
+    assignment_errors: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncEventSourcesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncEventSourcesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncEventSourcesRequestEventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    allowed_domains: NotRequired[builtins.list[builtins.str]]
+
+class _SyncEventSourcesResponseEventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    seller_id: NotRequired[builtins.str]
+    event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    managed_by: NotRequired[Literal['buyer', 'seller']]
+    setup: NotRequired[_SyncEventSourcesResponseEventSourcesItemSetup]
+    action: Required[Literal['created', 'updated', 'unchanged', 'deleted', 'failed']]
+    health: NotRequired[_ExternalCoreEventSourceHealth]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncGovernanceRequestAccountsItem(TypedDict, total=False):
+    account: Required[_SyncGovernanceRequestAccountsItemAccountVariant1 | _SyncGovernanceRequestAccountsItemAccountVariant2]
+    governance_agents: Required[builtins.list[_SyncGovernanceRequestAccountsItemGovernanceAgentsItem]]
+
+class _SyncGovernanceResponseAccountsItem(TypedDict, total=False):
+    account: Required[_SyncGovernanceResponseAccountsItemAccountVariant1 | _SyncGovernanceResponseAccountsItemAccountVariant2]
+    status: Required[Literal['synced', 'failed']]
+    governance_agents: NotRequired[builtins.list[_SyncGovernanceResponseAccountsItemGovernanceAgentsItem]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncPlansRequestPlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    brand: Required[_ExternalCoreBrandRef]
+    objectives: Required[builtins.str]
+    budget: Required[_SyncPlansRequestPlansItemBudgetVariant1 | _SyncPlansRequestPlansItemBudgetVariant2]
+    channels: NotRequired[_SyncPlansRequestPlansItemChannels]
+    flight: Required[_SyncPlansRequestPlansItemFlight]
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+    policy_ids: NotRequired[builtins.list[builtins.str]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    audience: NotRequired[_ExternalGovernanceAudienceConstraints]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    restricted_attributes_custom: NotRequired[builtins.list[builtins.str]]
+    min_audience_size: NotRequired[builtins.int]
+    human_review_required: NotRequired[builtins.bool]
+    custom_policies: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+    approved_sellers: NotRequired[builtins.list[builtins.str] | None]
+    delegations: NotRequired[builtins.list[_SyncPlansRequestPlansItemDelegationsItem]]
+    portfolio: NotRequired[_SyncPlansRequestPlansItemPortfolio]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncPlansResponsePlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    status: Required[Literal['active', 'error']]
+    version: Required[builtins.int]
+    categories: NotRequired[builtins.list[_SyncPlansResponsePlansItemCategoriesItem]]
+    resolved_policies: NotRequired[builtins.list[_SyncPlansResponsePlansItemResolvedPoliciesItem]]
+
+class _TasksGetResponseProgress(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+
+class _TasksGetResponseError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    details: NotRequired[_TasksGetResponseErrorDetails]
+
+class _TasksGetResponseHistoryItem(TypedDict, total=False):
+    timestamp: Required[builtins.str]
+    type: Required[Literal['request', 'response']]
+    data: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestFilters(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence']]
+    protocols: NotRequired[builtins.list[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence']]]
+    status: NotRequired[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    statuses: NotRequired[builtins.list[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]]
+    task_type: NotRequired[Literal['create_media_buy', 'update_media_buy', 'sync_creatives', 'activate_signal', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'get_rights', 'acquire_rights']]
+    task_types: NotRequired[builtins.list[Literal['create_media_buy', 'update_media_buy', 'sync_creatives', 'activate_signal', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'get_rights', 'acquire_rights']]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    task_ids: NotRequired[builtins.list[builtins.str]]
+    context_contains: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _TasksListRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_at', 'updated_at', 'status', 'task_type', 'protocol']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _TasksListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _TasksListResponseQuerySummary(TypedDict, total=False):
+    total_matching: NotRequired[builtins.int]
+    returned: NotRequired[builtins.int]
+    domain_breakdown: NotRequired[_TasksListResponseQuerySummaryDomainBreakdown]
+    status_breakdown: NotRequired[builtins.dict[builtins.str, builtins.int]]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_TasksListResponseQuerySummarySortApplied]
+
+class _TasksListResponseTasksItem(TypedDict, total=False):
+    task_id: Required[builtins.str]
+    task_type: Required[Literal['create_media_buy', 'update_media_buy', 'sync_creatives', 'activate_signal', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'get_rights', 'acquire_rights']]
+    domain: Required[Literal['media-buy', 'signals']]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    created_at: Required[builtins.str]
+    updated_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _TasksListResponsePagination(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _UpdateCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _UpdateContentStandardsRequestScope(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2]]
+
+class _UpdateMediaBuyRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateMediaBuyRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalMediaBuyPackageUpdate(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    budget: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bid_price: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[Literal[True]]
+    cancellation_reason: NotRequired[builtins.str]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    keyword_targets_add: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateKeywordTargetsAddItem]]
+    keyword_targets_remove: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateKeywordTargetsRemoveItem]]
+    negative_keywords_add: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateNegativeKeywordsAddItem]]
+    negative_keywords_remove: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateNegativeKeywordsRemoveItem]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    creatives: NotRequired[builtins.list[_ExternalCoreCreativeAsset]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdatePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdatePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ValidateContentDeliveryRequestRecordsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    artifact: Required[_ExternalContentStandardsArtifact]
+    country: NotRequired[builtins.str]
+    channel: NotRequired[builtins.str]
+    brand_context: NotRequired[_ValidateContentDeliveryRequestRecordsItemBrandContext]
+
+class _ValidateContentDeliveryResponseSummary(TypedDict, total=False):
+    total_records: Required[builtins.int]
+    passed_records: Required[builtins.int]
+    failed_records: Required[builtins.int]
+
+class _ValidateContentDeliveryResponseResultsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    verdict: Required[Literal['pass', 'fail']]
+    features: NotRequired[builtins.list[_ValidateContentDeliveryResponseResultsItemFeaturesItem]]
+
+class _ValidatePropertyDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ValidatePropertyDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalPropertyDeliveryRecord(TypedDict, total=False):
+    identifier: Required[_ExternalCoreIdentifier]
+    impressions: Required[builtins.int]
+    record_id: NotRequired[builtins.str]
+    sales_agent_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidatePropertyDeliveryResponseSummary(TypedDict, total=False):
+    total_records: Required[builtins.int]
+    total_impressions: Required[builtins.int]
+    compliant_records: Required[builtins.int]
+    compliant_impressions: Required[builtins.int]
+    non_compliant_records: Required[builtins.int]
+    non_compliant_impressions: Required[builtins.int]
+    not_covered_records: Required[builtins.int]
+    not_covered_impressions: Required[builtins.int]
+    unidentified_records: Required[builtins.int]
+    unidentified_impressions: Required[builtins.int]
+
+class _ValidatePropertyDeliveryResponseAggregate(TypedDict, total=False):
+    score: NotRequired[builtins.float]
+    grade: NotRequired[builtins.str]
+    label: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _ValidatePropertyDeliveryResponseAuthorizationSummary(TypedDict, total=False):
+    records_checked: Required[builtins.int]
+    impressions_checked: Required[builtins.int]
+    authorized_records: Required[builtins.int]
+    authorized_impressions: Required[builtins.int]
+    unauthorized_records: Required[builtins.int]
+    unauthorized_impressions: Required[builtins.int]
+    unknown_records: Required[builtins.int]
+    unknown_impressions: Required[builtins.int]
+
+class _ExternalPropertyValidationResult(TypedDict, total=False):
+    identifier: Required[_ExternalCoreIdentifier]
+    record_id: NotRequired[builtins.str]
+    status: Required[Literal['compliant', 'non_compliant', 'not_covered', 'unidentified']]
+    impressions: Required[builtins.int]
+    features: NotRequired[builtins.list[_ExternalPropertyValidationResultFeaturesItem]]
+    authorization: NotRequired[_ExternalPropertyAuthorizationResult]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreBrandRefDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCorePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalBrandRightsTermsExclusivity(TypedDict, total=False):
+    scope: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRightsConstraintRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCoreIndustryIdentifier(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock']]
+    value: Required[builtins.str]
+
+class _ExternalCoreProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_ExternalCoreProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_ExternalCoreProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_ExternalCoreProvenanceC2pa]
+    disclosure: NotRequired[_ExternalCoreProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_ExternalCoreProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponsePreviewPreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1 | _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2 | _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3]]
+    input: Required[_BuildCreativeResponsePreviewPreviewsItemInput]
+
+class _BuildCreativeResponsePreview2PreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    renders: Required[builtins.list[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1 | _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2 | _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3]]
+    input: Required[_BuildCreativeResponsePreview2PreviewsItemInput]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactMetadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _ExternalContentStandardsArtifactIdentifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalCorePlannedDeliveryGeo(TypedDict, total=False):
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreFrequencyCap(TypedDict, total=False):
+    suppress: NotRequired[_ExternalCoreFrequencyCapSuppress]
+    suppress_minutes: NotRequired[builtins.float]
+    max_impressions: NotRequired[builtins.int]
+    per: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    window: NotRequired[_ExternalCoreFrequencyCapWindow]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _CheckGovernanceRequestDeliveryMetricsReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _CheckGovernanceRequestDeliveryMetricsAudienceDistribution(TypedDict, total=False):
+    baseline: Required[Literal['census', 'platform', 'custom']]
+    baseline_description: NotRequired[builtins.str]
+    indices: Required[builtins.dict[builtins.str, builtins.float]]
+    cumulative_indices: NotRequired[builtins.dict[builtins.str, builtins.float]]
+
+class _ExternalCoreBusinessEntityAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _ExternalCoreBusinessEntityContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _ExternalCoreBusinessEntityBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _ComplyTestControllerRequestParamsReportedSpend(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ContextMatchRequestGeoMetro(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    value: Required[builtins.str]
+
+class _ExternalCoreSellerAgentRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: NotRequired[builtins.str]
+
+class _ExternalTmpOfferPrice(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: NotRequired[builtins.str]
+    model: Required[Literal['cpm', 'cpc', 'cpcv', 'cpa', 'flat']]
+
+class _ContextMatchResponseSignalsTargetingKvsItem(TypedDict, total=False):
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _ExternalCoreContentRating(TypedDict, total=False):
+    system: Required[Literal['tv_parental', 'mpaa', 'podcast', 'esrb', 'bbfc', 'fsk', 'acb', 'chvrs', 'csa', 'pegi', 'custom']]
+    rating: Required[builtins.str]
+
+class _ExternalCollectionCollectionListFiltersExcludeDistributionIdsItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _ExternalCollectionCollectionListAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalCollectionCollectionListAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_ExternalCollectionCollectionListBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _ExternalGovernancePolicyEntryExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_Exemplar]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant1(TypedDict, total=False):
+    type: Required[Literal['url']]
+    value: Required[builtins.str]
+    language: NotRequired[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4]]
+    metadata: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant2 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreReportingWebhookAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _CreateMediaBuyRequestArtifactWebhookAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalCoreAccountCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAccountSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    categories: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreAccountReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _ExternalPricingOptionsPriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant1 | _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant2]]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalCorePackageOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant2 | _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+    acknowledged_at: NotRequired[builtins.str]
+
+class _ExternalCoreFeatureRequirement(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    allowed_values: NotRequired[builtins.list[Any]]
+    if_not_covered: NotRequired[Literal['exclude', 'include']]
+    policy_id: NotRequired[builtins.str]
+
+class _ExternalPropertyPropertyListAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalPropertyPropertyListAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalPropertyPropertyListPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetAccountFinancialsResponseBalanceLastTopUp(TypedDict, total=False):
+    amount: Required[builtins.float]
+    date: Required[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant1(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    replay_ttl_seconds: Required[builtins.int]
+    account_id_is_opaque: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant2(TypedDict, total=False):
+    supported: Required[Literal[False]]
+
+class _ExternalCoreMediaBuyFeatures(TypedDict, total=False):
+    inline_creative_management: NotRequired[builtins.bool]
+    property_list_filtering: NotRequired[builtins.bool]
+    catalog_management: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecution(TypedDict, total=False):
+    trusted_match: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTrustedMatch]
+    axe_integrations: NotRequired[builtins.list[builtins.str]]
+    creative_specs: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionCreativeSpecs]
+    targeting: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargeting]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceTargeting(TypedDict, total=False):
+    supported_identifier_types: Required[builtins.list[Literal['hashed_email', 'hashed_phone']]]
+    supports_platform_customer_id: NotRequired[builtins.bool]
+    supported_uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'other']]]
+    minimum_audience_size: Required[builtins.int]
+    matching_latency_hours: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceTargetingMatchingLatencyHours]
+
+class _GetAdcpCapabilitiesResponseMediaBuyConversionTracking(TypedDict, total=False):
+    multi_source_event_dedup: NotRequired[builtins.bool]
+    supported_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    supported_uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'other']]]
+    supported_hashed_identifiers: NotRequired[builtins.list[Literal['hashed_email', 'hashed_phone']]]
+    supported_action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    attribution_windows: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseMediaBuyConversionTrackingAttributionWindowsItem]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyContentStandards(TypedDict, total=False):
+    supports_local_evaluation: NotRequired[builtins.bool]
+    supported_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    supports_webhook_delivery: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyPortfolio(TypedDict, total=False):
+    publisher_domains: Required[builtins.list[builtins.str]]
+    primary_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    primary_countries: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    advertising_policies: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseSignalsFeatures(TypedDict, total=False):
+    catalog_signals: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    type: Required[Literal['binary', 'quantitative', 'categorical']]
+    range: NotRequired[_GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItemRange]
+    categories: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    type: Required[Literal['binary', 'quantitative', 'categorical']]
+    range: NotRequired[_GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItemRange]
+    categories: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpoint(TypedDict, total=False):
+    transports: Required[builtins.list[_GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpointTransportsItem]]
+    preferred: NotRequired[Literal['mcp', 'a2a']]
+
+class _GetAdcpCapabilitiesResponseIdentityKeyOrigins(TypedDict, total=False):
+    governance_signing: NotRequired[builtins.str]
+    request_signing: NotRequired[builtins.str]
+    webhook_signing: NotRequired[builtins.str]
+    tmp_signing: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseIdentityCompromiseNotification(TypedDict, total=False):
+    emits: NotRequired[builtins.bool]
+    accepts: NotRequired[builtins.bool]
+
+class _FontRoleVariant2(TypedDict, total=False):
+    family: Required[builtins.str]
+    files: NotRequired[builtins.list[_FontRoleVariant2FilesItem]]
+    opentype_features: NotRequired[builtins.list[builtins.str]]
+    fallbacks: NotRequired[builtins.list[builtins.str]]
+
+class _GetCollectionListResponseCollectionsItemDistributionIdsItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreDeliveryMetrics(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreDeliveryMetricsQuartileData]
+    dooh_metrics: NotRequired[_ExternalCoreDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsByActionSourceItem]]
+
+class _ExternalCoreCreativeVariant(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCreativeVariantByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCreativeVariantQuartileData]
+    dooh_metrics: NotRequired[_ExternalCoreCreativeVariantDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCreativeVariantViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCreativeVariantByActionSourceItem]]
+    variant_id: Required[builtins.str]
+    manifest: NotRequired[_ExternalCoreCreativeManifest]
+    generation_context: NotRequired[_ExternalCoreCreativeVariantGenerationContext]
+
+class _GetMediaBuyArtifactsResponseArtifactsItemBrandContext(TypedDict, total=False):
+    brand_id: NotRequired[builtins.str]
+    sku_id: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryRequestAttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryRequestAttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsGeo(TypedDict, total=False):
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDeviceType(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDevicePlatform(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsAudience(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsPlacement(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _ExternalCoreAttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreAttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotals(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByActionSourceItem]]
+    effective_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByActionSourceItem]]
+    package_id: Required[builtins.str]
+    pacing_index: NotRequired[builtins.float]
+    pricing_model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    rate: Required[builtins.float]
+    currency: Required[builtins.str]
+    delivery_status: NotRequired[Literal['delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    paused: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    measurement_window: NotRequired[builtins.str]
+    supersedes_window: NotRequired[builtins.str]
+    by_catalog_item: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItem]]
+    by_creative: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItem]]
+    by_keyword: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItem]]
+    by_geo: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItem]]
+    by_geo_truncated: NotRequired[builtins.bool]
+    by_device_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItem]]
+    by_device_type_truncated: NotRequired[builtins.bool]
+    by_device_platform: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItem]]
+    by_device_platform_truncated: NotRequired[builtins.bool]
+    by_audience: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItem]]
+    by_audience_truncated: NotRequired[builtins.bool]
+    by_placement: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItem]]
+    by_placement_truncated: NotRequired[builtins.bool]
+    daily_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDailyBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemDailyBreakdownItem(TypedDict, total=False):
+    date: Required[builtins.str]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemHistoryItem(TypedDict, total=False):
+    revision: Required[builtins.int]
+    timestamp: Required[builtins.str]
+    actor: NotRequired[builtins.str]
+    action: Required[builtins.str]
+    summary: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemCancellation]
+    creative_deadline: NotRequired[builtins.str]
+    creative_approvals: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemCreativeApprovalsItem]]
+    format_ids_pending: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    snapshot: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemSnapshot]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemBudget(TypedDict, total=False):
+    authorized: NotRequired[builtins.float]
+    committed: NotRequired[builtins.float]
+    remaining: NotRequired[builtins.float]
+    utilization_pct: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemChannelAllocationValue(TypedDict, total=False):
+    committed: NotRequired[builtins.float]
+    pct: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemSummary(TypedDict, total=False):
+    checks_performed: NotRequired[builtins.int]
+    outcomes_reported: NotRequired[builtins.int]
+    statuses: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryStatuses]
+    findings_count: NotRequired[builtins.int]
+    escalations: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemSummaryEscalationsItem]]
+    drift_metrics: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryDriftMetrics]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    type: Required[Literal['check', 'outcome']]
+    timestamp: Required[builtins.str]
+    plan_id: NotRequired[builtins.str]
+    caller: NotRequired[builtins.str]
+    tool: NotRequired[builtins.str]
+    status: NotRequired[Literal['approved', 'denied', 'conditions']]
+    check_type: NotRequired[Literal['intent', 'execution']]
+    mode: NotRequired[Literal['audit', 'advisory', 'enforce']]
+    explanation: NotRequired[builtins.str]
+    policies_evaluated: NotRequired[builtins.list[builtins.str]]
+    categories_evaluated: NotRequired[builtins.list[builtins.str]]
+    findings: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItemFindingsItem]]
+    outcome: NotRequired[Literal['completed', 'failed', 'delivery']]
+    committed_budget: NotRequired[builtins.float]
+    governance_context: NotRequired[builtins.str]
+    plan_hash: NotRequired[builtins.str]
+    purchase_type: NotRequired[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']]
+    outcome_status: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemGovernedActionsItem(TypedDict, total=False):
+    governance_context: Required[builtins.str]
+    purchase_type: Required[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']]
+    status: Required[Literal['active', 'suspended', 'completed']]
+    committed: Required[builtins.float]
+    check_count: Required[builtins.int]
+    seller_reference: NotRequired[builtins.str]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant1(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant2(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant3(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['by_tag']]
+    property_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCorePlacement(TypedDict, total=False):
+    placement_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    tags: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+
+class _ExternalCoreProductPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['vcpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpc']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpcv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant5Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant6(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpp']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant6Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant7(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpa']]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    fixed_price: Required[builtins.float]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant8(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['flat_rate']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: NotRequired[_ExternalCoreProductPricingOptionsItemVariant8Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant9(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['time']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant9Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreDeliveryForecast(TypedDict, total=False):
+    points: Required[builtins.list[_ExternalCoreForecastPoint]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreOutcomeMeasurement(TypedDict, total=False):
+    type: Required[builtins.str]
+    attribution: Required[builtins.str]
+    window: NotRequired[_ExternalCoreOutcomeMeasurementWindow]
+    reporting: Required[builtins.str]
+
+class _ExternalCoreProductDeliveryMeasurement(TypedDict, total=False):
+    provider: Required[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _ExternalCoreCancellationPolicy(TypedDict, total=False):
+    notice_period: Required[_ExternalCoreDuration]
+    cancellation_fee: Required[_ExternalCoreCancellationPolicyCancellationFee]
+
+class _ExternalCoreReportingCapabilities(TypedDict, total=False):
+    available_reporting_frequencies: Required[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    expected_delay_minutes: Required[builtins.int]
+    timezone: Required[builtins.str]
+    supports_webhooks: Required[builtins.bool]
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'video_completions', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'viewability', 'engagement_rate', 'views', 'completed_views', 'leads', 'reach', 'frequency', 'grps', 'quartile_data', 'dooh_metrics', 'cost_per_click']]]
+    supports_creative_breakdown: NotRequired[builtins.bool]
+    supports_keyword_breakdown: NotRequired[builtins.bool]
+    supports_geo_breakdown: NotRequired[_ExternalCoreGeoBreakdownSupport]
+    supports_device_type_breakdown: NotRequired[builtins.bool]
+    supports_device_platform_breakdown: NotRequired[builtins.bool]
+    supports_audience_breakdown: NotRequired[builtins.bool]
+    supports_placement_breakdown: NotRequired[builtins.bool]
+    date_range_support: Required[Literal['date_range', 'lifetime_only']]
+    measurement_windows: NotRequired[builtins.list[_ExternalCoreMeasurementWindow]]
+
+class _ExternalCoreCreativePolicy(TypedDict, total=False):
+    co_branding: Required[Literal['required', 'optional', 'none']]
+    landing_page: Required[Literal['any', 'retailer_site_only', 'must_include_retailer']]
+    templates_available: Required[builtins.bool]
+    provenance_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant1(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant2(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    signal_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant3(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_tag']]
+    signal_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    supported_reach_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_view_durations: NotRequired[builtins.list[builtins.float]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _ExternalCoreMeasurementReadiness(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    required_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    missing_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    issues: NotRequired[builtins.list[_ExternalCoreDiagnosticIssue]]
+    notes: NotRequired[builtins.str]
+
+class _ExternalCoreProductConversionTracking(TypedDict, total=False):
+    action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    platform_managed: NotRequired[builtins.bool]
+
+class _ExternalCoreProductCatalogMatch(TypedDict, total=False):
+    matched_gtins: NotRequired[builtins.list[builtins.str]]
+    matched_ids: NotRequired[builtins.list[builtins.str]]
+    matched_count: NotRequired[builtins.int]
+    submitted_count: Required[builtins.int]
+
+class _ExternalCoreProductProductCard(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductProductCardDetailed(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCollectionSelector(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreInstallment(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    collection_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    season: NotRequired[builtins.str]
+    installment_number: NotRequired[builtins.str]
+    scheduled_at: NotRequired[builtins.str]
+    status: NotRequired[Literal['scheduled', 'tentative', 'live', 'postponed', 'cancelled', 'aired', 'published']]
+    duration_seconds: NotRequired[builtins.int]
+    flexible_end: NotRequired[builtins.bool]
+    valid_until: NotRequired[builtins.str]
+    content_rating: NotRequired[_ExternalCoreContentRating]
+    topics: NotRequired[builtins.list[builtins.str]]
+    special: NotRequired[_ExternalCoreSpecial]
+    guest_talent: NotRequired[builtins.list[_ExternalCoreTalent]]
+    ad_inventory: NotRequired[_ExternalCoreAdInventoryConfig]
+    deadlines: NotRequired[_ExternalCoreInstallmentDeadlines]
+    derivative_of: NotRequired[_ExternalCoreInstallmentDerivativeOf]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTrustedMatch(TypedDict, total=False):
+    context_match: Required[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+    dynamic_brands: NotRequired[builtins.bool]
+    providers: NotRequired[builtins.list[_ExternalCoreProductTrustedMatchProvidersItem]]
+
+class _ExternalCoreProductMaterialSubmission(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    instructions: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCatalogFieldMapping(TypedDict, total=False):
+    feed_field: NotRequired[builtins.str]
+    catalog_field: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    value: NotRequired[Any]
+    transform: NotRequired[Literal['date', 'divide', 'boolean', 'split']]
+    format: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    by: NotRequired[builtins.float]
+    separator: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductFiltersBudgetRange(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreProductFiltersMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    code: Required[builtins.str]
+
+class _ExternalCoreProductFiltersTrustedMatch(TypedDict, total=False):
+    providers: NotRequired[builtins.list[_ExternalCoreProductFiltersTrustedMatchProvidersItem]]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+
+class _ExternalCoreProductFiltersRequiredGeoTargetingItem(TypedDict, total=False):
+    level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1(TypedDict, total=False):
+    signal_id: Required[_ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2(TypedDict, total=False):
+    signal_id: Required[_ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3(TypedDict, total=False):
+    signal_id: Required[_ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalCoreProductFiltersPostalAreasItem(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_ExternalCoreProductFiltersGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant1Geometry]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_ExternalCoreProductFiltersGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant2Geometry]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant3Radius]
+    geometry: Required[_ExternalCoreProductFiltersGeoProximityItemVariant3Geometry]
+
+class _ExternalCoreProductFiltersKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: NotRequired[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreProductAllocation(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    allocation_percentage: Required[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    rationale: NotRequired[builtins.str]
+    sequence: NotRequired[builtins.int]
+    tags: NotRequired[builtins.list[builtins.str]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    daypart_targets: NotRequired[builtins.list[_ExternalCoreDaypartTarget]]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreInsertionOrder(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    terms: NotRequired[_ExternalCoreInsertionOrderTerms]
+    terms_url: NotRequired[builtins.str]
+    signing_url: NotRequired[builtins.str]
+    requires_signature: Required[builtins.bool]
+
+class _ExternalCoreProposalTotalBudgetGuidance(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    recommended: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _GetProductsResponseIncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetRightsResponseRightsItemExclusivityStatus(TypedDict, total=False):
+    available: NotRequired[builtins.bool]
+    existing_exclusives: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalBrandRightsPricingOption(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    price: Required[builtins.float]
+    currency: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    period: NotRequired[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual', 'one_time']]
+    impression_cap: NotRequired[builtins.int]
+    overage_cpm: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetRightsResponseRightsItemPreviewAssetsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    usage: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_GetSignalsResponseSignalsItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalContentStandardsContentStandardsPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatRendersItemVariant1(TypedDict, total=False):
+    role: Required[builtins.str]
+    parameters_from_format_id: NotRequired[builtins.bool]
+    dimensions: Required[_ExternalCoreFormatRendersItemVariant1Dimensions]
+
+class _ExternalCoreFormatRendersItemVariant2(TypedDict, total=False):
+    role: Required[builtins.str]
+    parameters_from_format_id: Required[Literal[True]]
+    dimensions: NotRequired[_ExternalCoreFormatRendersItemVariant2Dimensions]
+
+class _ExternalCoreFormatAssetsItemVariant1(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['image']]
+    requirements: NotRequired[_ExternalCoreRequirementsImageAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant2(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['video']]
+    requirements: NotRequired[_ExternalCoreRequirementsVideoAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant3(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['audio']]
+    requirements: NotRequired[_ExternalCoreRequirementsAudioAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant4(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['text']]
+    requirements: NotRequired[_ExternalCoreRequirementsTextAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant5(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['markdown']]
+    requirements: NotRequired[_ExternalCoreRequirementsMarkdownAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant6(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['html']]
+    requirements: NotRequired[_ExternalCoreRequirementsHtmlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant7(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['css']]
+    requirements: NotRequired[_ExternalCoreRequirementsCssAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant8(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['javascript']]
+    requirements: NotRequired[_ExternalCoreRequirementsJavascriptAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant9(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['vast']]
+    requirements: NotRequired[_ExternalCoreRequirementsVastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant10(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['daast']]
+    requirements: NotRequired[_ExternalCoreRequirementsDaastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant11(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['url']]
+    requirements: NotRequired[_ExternalCoreRequirementsUrlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant12(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['webhook']]
+    requirements: NotRequired[_ExternalCoreRequirementsWebhookAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant13(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['brief']]
+
+class _ExternalCoreFormatAssetsItemVariant14(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['catalog']]
+    requirements: NotRequired[_ExternalCoreRequirementsCatalogRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15(TypedDict, total=False):
+    item_type: Required[Literal['repeatable_group']]
+    asset_group_id: Required[builtins.str]
+    required: Required[builtins.bool]
+    min_count: Required[builtins.int]
+    max_count: Required[builtins.int]
+    selection_mode: NotRequired[Literal['sequential', 'optimize']]
+    assets: Required[builtins.list[_ExternalCoreFormatAssetsItemVariant15AssetsItemVariant1 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant2 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant3 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant4 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant5 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant6 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant7 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant8 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant9 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant10 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant11 | _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant12]]
+
+class _ExternalCoreFormatFormatCard(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatAccessibility(TypedDict, total=False):
+    wcag_level: Required[Literal['A', 'AA', 'AAA']]
+    requires_accessible_assets: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatDisclosureCapabilitiesItem(TypedDict, total=False):
+    position: Required[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]
+    persistence: Required[builtins.list[Literal['continuous', 'initial', 'flexible']]]
+
+class _ExternalCoreFormatFormatCardDetailed(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreFormatPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeFiltersAccountsItemVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalCoreCreativeFiltersAccountsItemVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListCreativesResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: NotRequired[builtins.str]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ExternalCoreCreativeVariable(TypedDict, total=False):
+    variable_id: Required[builtins.str]
+    name: Required[builtins.str]
+    variable_type: Required[Literal['text', 'image', 'video', 'audio', 'url', 'number', 'boolean', 'color', 'date']]
+    default_value: NotRequired[builtins.str]
+    required: NotRequired[builtins.bool]
+
+class _ListCreativesResponseCreativesItemAssignments(TypedDict, total=False):
+    assignment_count: Required[builtins.int]
+    assigned_packages: NotRequired[builtins.list[_ListCreativesResponseCreativesItemAssignmentsAssignedPackagesItem]]
+
+class _ListCreativesResponseCreativesItemSnapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.int]
+    last_served: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemItemsItemVariant1(TypedDict, total=False):
+    asset_kind: Required[Literal['media']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content_uri: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemItemsItemVariant2(TypedDict, total=False):
+    asset_kind: Required[Literal['text']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content: Required[builtins.str | builtins.list[builtins.str]]
+
+class _ListCreativesResponseCreativesItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ListCreativesResponseCreativesItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreUserMatch(TypedDict, total=False):
+    uids: NotRequired[builtins.list[_ExternalCoreUserMatchUidsItem]]
+    hashed_email: NotRequired[builtins.str]
+    hashed_phone: NotRequired[builtins.str]
+    click_id: NotRequired[builtins.str]
+    click_id_type: NotRequired[builtins.str]
+    client_ip: NotRequired[builtins.str]
+    client_user_agent: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreEventCustomData(TypedDict, total=False):
+    value: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    order_id: NotRequired[builtins.str]
+    content_ids: NotRequired[builtins.list[builtins.str]]
+    content_type: NotRequired[builtins.str]
+    content_name: NotRequired[builtins.str]
+    content_category: NotRequired[builtins.str]
+    num_items: NotRequired[builtins.int]
+    search_string: NotRequired[builtins.str]
+    contents: NotRequired[builtins.list[_ExternalCoreEventCustomDataContentsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_PackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: Required[_PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView]
+
+class _ExternalCoreTargetingGeoMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoMetrosExcludeItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoPostalAreasItem(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoPostalAreasExcludeItem(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreDaypartTarget(TypedDict, total=False):
+    days: Required[builtins.list[Literal['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']]]
+    start_hour: Required[builtins.int]
+    end_hour: Required[builtins.int]
+    label: NotRequired[builtins.str]
+
+class _ExternalCoreCollectionListRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _ExternalCoreTargetingAgeRestriction(TypedDict, total=False):
+    min: Required[builtins.int]
+    verification_required: NotRequired[builtins.bool]
+    accepted_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _ExternalCoreTargetingStoreCatchmentsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    store_ids: NotRequired[builtins.list[builtins.str]]
+    catchment_ids: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_ExternalCoreTargetingGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant1Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_ExternalCoreTargetingGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant2Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant3Radius]
+    geometry: Required[_ExternalCoreTargetingGeoProximityItemVariant3Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingKeywordTargetsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalCoreTargetingNegativeKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+
+class _ExternalCoreMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _ExternalCoreCreativeAssetInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeRequestRequestsItemInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1Response(TypedDict, total=False):
+    previews: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2Response(TypedDict, total=False):
+    previews: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1Embedding]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant2Embedding]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant3Embedding]
+
+class _ReportPlanOutcomeRequestSellerResponsePackagesItem(TypedDict, total=False):
+    budget: NotRequired[builtins.float]
+
+class _ReportPlanOutcomeRequestDeliveryReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ReportUsageRequestUsageItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ReportUsageRequestUsageItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalSponsoredIntelligenceSiIdentityPrivacyPolicyAcknowledged(TypedDict, total=False):
+    brand_policy_url: NotRequired[builtins.str]
+    brand_policy_version: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentityUser(TypedDict, total=False):
+    email: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    locale: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+    shipping_address: NotRequired[_ExternalSponsoredIntelligenceSiIdentityUserShippingAddress]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalities(TypedDict, total=False):
+    conversational: NotRequired[builtins.bool]
+    voice: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVoiceVariant2]
+    video: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVideoVariant2]
+    avatar: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesAvatarVariant2]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesComponents(TypedDict, total=False):
+    standard: NotRequired[builtins.list[Literal['text', 'link', 'image', 'product_card', 'carousel', 'action_button']]]
+    extensions: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesCommerce(TypedDict, total=False):
+    acp_checkout: NotRequired[builtins.bool]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesA2ui(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    catalogs: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalSponsoredIntelligenceSiUiElement(TypedDict, total=False):
+    type: Required[Literal['text', 'link', 'image', 'product_card', 'carousel', 'action_button', 'app_handoff', 'integration_actions']]
+    data: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalA2uiSurface(TypedDict, total=False):
+    surfaceId: Required[builtins.str]
+    catalogId: NotRequired[builtins.str]
+    components: Required[builtins.list[_ExternalA2uiComponent]]
+    rootId: NotRequired[builtins.str]
+    dataModel: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiSendMessageResponseHandoffIntent(TypedDict, total=False):
+    action: NotRequired[builtins.str]
+    product: NotRequired[builtins.dict[builtins.str, Any]]
+    price: NotRequired[_SiSendMessageResponseHandoffIntentPrice]
+
+class _SiSendMessageResponseHandoffContextForCheckout(TypedDict, total=False):
+    conversation_summary: NotRequired[builtins.str]
+    applied_offers: NotRequired[builtins.list[builtins.str]]
+
+class _SiTerminateSessionRequestTerminationContextTransactionIntent(TypedDict, total=False):
+    action: NotRequired[Literal['purchase', 'subscribe']]
+    product: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsResponseAccountsItemSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _SyncAccountsResponseAccountsItemCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAudienceMember(TypedDict, total=False):
+    external_id: Required[builtins.str]
+    hashed_email: NotRequired[builtins.str]
+    hashed_phone: NotRequired[builtins.str]
+    uids: NotRequired[builtins.list[_ExternalCoreAudienceMemberUidsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAudiencesResponseAudiencesItemMatchBreakdownItem(TypedDict, total=False):
+    id_type: Required[Literal['hashed_email', 'hashed_phone', 'rampid', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'other']]
+    submitted: Required[builtins.int]
+    matched: Required[builtins.int]
+    match_rate: Required[builtins.float]
+
+class _SyncCatalogsResponseCatalogsItemItemIssuesItem(TypedDict, total=False):
+    item_id: Required[builtins.str]
+    status: Required[Literal['approved', 'pending', 'rejected', 'warning']]
+    reasons: NotRequired[builtins.list[builtins.str]]
+
+class _SyncEventSourcesResponseEventSourcesItemSetup(TypedDict, total=False):
+    snippet: NotRequired[builtins.str]
+    snippet_type: NotRequired[Literal['javascript', 'html', 'pixel_url', 'server_only']]
+    instructions: NotRequired[builtins.str]
+
+class _ExternalCoreEventSourceHealth(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    detail: NotRequired[_ExternalCoreEventSourceHealthDetail]
+    match_rate: NotRequired[builtins.float]
+    last_event_at: NotRequired[builtins.str]
+    evaluated_at: NotRequired[builtins.str]
+    events_received_24h: NotRequired[builtins.int]
+    issues: NotRequired[builtins.list[_ExternalCoreDiagnosticIssue]]
+
+class _SyncGovernanceRequestAccountsItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncGovernanceRequestAccountsItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncGovernanceRequestAccountsItemGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    authentication: Required[_SyncGovernanceRequestAccountsItemGovernanceAgentsItemAuthentication]
+    categories: NotRequired[builtins.list[builtins.str]]
+
+class _SyncGovernanceResponseAccountsItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncGovernanceResponseAccountsItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncGovernanceResponseAccountsItemGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    categories: NotRequired[builtins.list[builtins.str]]
+
+class _SyncPlansRequestPlansItemBudgetVariant1(TypedDict, total=False):
+    total: Required[builtins.float]
+    currency: Required[builtins.str]
+    per_seller_max_pct: NotRequired[builtins.float]
+    reallocation_threshold: Required[builtins.float]
+    reallocation_unlimited: NotRequired[builtins.bool]
+    allocations: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemBudgetVariant1AllocationsValue]]
+
+class _SyncPlansRequestPlansItemBudgetVariant2(TypedDict, total=False):
+    total: Required[builtins.float]
+    currency: Required[builtins.str]
+    per_seller_max_pct: NotRequired[builtins.float]
+    reallocation_threshold: NotRequired[builtins.float]
+    reallocation_unlimited: Required[Literal[True]]
+    allocations: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemBudgetVariant2AllocationsValue]]
+
+class _SyncPlansRequestPlansItemChannels(TypedDict, total=False):
+    required: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    allowed: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    mix_targets: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemChannelsMixTargetsValue]]
+
+class _SyncPlansRequestPlansItemFlight(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraints(TypedDict, total=False):
+    include: NotRequired[builtins.list[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant4]]
+    exclude: NotRequired[builtins.list[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant4]]
+
+class _SyncPlansRequestPlansItemDelegationsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    authority: Required[Literal['full', 'execute_only', 'propose_only']]
+    budget_limit: NotRequired[_SyncPlansRequestPlansItemDelegationsItemBudgetLimit]
+    markets: NotRequired[builtins.list[builtins.str]]
+    expires_at: NotRequired[builtins.str]
+
+class _SyncPlansRequestPlansItemPortfolio(TypedDict, total=False):
+    member_plan_ids: Required[builtins.list[builtins.str]]
+    total_budget_cap: NotRequired[_SyncPlansRequestPlansItemPortfolioTotalBudgetCap]
+    shared_policy_ids: NotRequired[builtins.list[builtins.str]]
+    shared_exclusions: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+
+class _SyncPlansResponsePlansItemCategoriesItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    status: Required[Literal['active', 'inactive']]
+
+class _SyncPlansResponsePlansItemResolvedPoliciesItem(TypedDict, total=False):
+    policy_id: Required[builtins.str]
+    source: Required[Literal['explicit', 'auto_applied']]
+    enforcement: Required[Literal['must', 'should', 'may']]
+    reason: NotRequired[builtins.str]
+
+class _TasksGetResponseErrorDetails(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence']]
+    operation: NotRequired[builtins.str]
+    specific_context: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksListResponseQuerySummaryDomainBreakdown(TypedDict, total=False):
+    signals: NotRequired[builtins.int]
+
+class _TasksListResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: Required[builtins.str]
+    direction: Required[Literal['asc', 'desc']]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant1(TypedDict, total=False):
+    type: Required[Literal['url']]
+    value: Required[builtins.str]
+    language: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4]]
+    metadata: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant2 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateKeywordTargetsAddItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateKeywordTargetsRemoveItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateNegativeKeywordsAddItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateNegativeKeywordsRemoveItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ValidateContentDeliveryRequestRecordsItemBrandContext(TypedDict, total=False):
+    brand_id: NotRequired[builtins.str]
+    sku_id: NotRequired[builtins.str]
+
+class _ValidateContentDeliveryResponseResultsItemFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalPropertyValidationResultFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    requirement: NotRequired[_ExternalPropertyValidationResultFeaturesItemRequirement]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalPropertyAuthorizationResult(TypedDict, total=False):
+    status: Required[Literal['authorized', 'unauthorized', 'unknown']]
+    publisher_domain: NotRequired[builtins.str]
+    sales_agent_url: NotRequired[builtins.str]
+    violation: NotRequired[_ExternalPropertyAuthorizationResultViolation]
+
+class _ExternalCoreProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _ExternalCoreProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _ExternalCoreProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_ExternalCoreProvenanceDisclosureJurisdictionsItem]]
+
+class _ExternalCoreProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalCoreFrequencyCapSuppress(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreFrequencyCapWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _Exemplar(TypedDict, total=False):
+    scenario: Required[builtins.str]
+    explanation: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: Required[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView]
+
+class _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: Required[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostView]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTrustedMatch(TypedDict, total=False):
+    surfaces: NotRequired[builtins.list[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'streaming_audio', 'ai_assistant']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionCreativeSpecs(TypedDict, total=False):
+    vast_versions: NotRequired[builtins.list[builtins.str]]
+    mraid_versions: NotRequired[builtins.list[builtins.str]]
+    vpaid: NotRequired[builtins.bool]
+    simid: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargeting(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.bool]
+    geo_regions: NotRequired[builtins.bool]
+    geo_metros: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoMetros]
+    geo_postal_areas: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoPostalAreas]
+    age_restriction: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingAgeRestriction]
+    language: NotRequired[builtins.bool]
+    keyword_targets: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingKeywordTargets]
+    negative_keywords: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingNegativeKeywords]
+    geo_proximity: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoProximity]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceTargetingMatchingLatencyHours(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+
+class _GetAdcpCapabilitiesResponseMediaBuyConversionTrackingAttributionWindowsItem(TypedDict, total=False):
+    event_type: NotRequired[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    post_click: Required[builtins.list[_ExternalCoreDuration]]
+    post_view: NotRequired[builtins.list[_ExternalCoreDuration]]
+
+class _GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpointTransportsItem(TypedDict, total=False):
+    type: Required[Literal['mcp', 'a2a']]
+    url: Required[builtins.str]
+
+class _FontRoleVariant2FilesItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    weight: NotRequired[builtins.int]
+    weight_range: NotRequired[builtins.list[builtins.int]]
+    style: NotRequired[Literal['normal', 'italic', 'oblique']]
+
+class _ExternalCoreDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreDeliveryMetricsViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCreativeVariantDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCreativeVariantViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCreativeVariantByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantGenerationContext(TypedDict, total=False):
+    context_type: NotRequired[builtins.str]
+    artifact: NotRequired[_ExternalCoreCreativeVariantGenerationContextArtifact]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemByActionSourceItem]]
+    content_id: Required[builtins.str]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemByActionSourceItem]]
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemByActionSourceItem]]
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemByActionSourceItem]]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByActionSourceItem]]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByActionSourceItem]]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByActionSourceItem]]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByActionSourceItem]]
+    placement_id: Required[builtins.str]
+    placement_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDailyBreakdownItem(TypedDict, total=False):
+    date: Required[builtins.str]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemCreativeApprovalsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    approval_status: Required[Literal['pending_review', 'approved', 'rejected']]
+    rejection_reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemSnapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    currency: NotRequired[builtins.str]
+    clicks: NotRequired[builtins.float]
+    pacing_index: NotRequired[builtins.float]
+    delivery_status: NotRequired[Literal['delivering', 'not_delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryStatuses(TypedDict, total=False):
+    approved: NotRequired[builtins.int]
+    denied: NotRequired[builtins.int]
+    conditions: NotRequired[builtins.int]
+    human_reviewed: NotRequired[builtins.int]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryEscalationsItem(TypedDict, total=False):
+    check_id: Required[builtins.str]
+    reason: Required[builtins.str]
+    resolution: NotRequired[builtins.str]
+    resolved_at: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryDriftMetrics(TypedDict, total=False):
+    escalation_rate: NotRequired[builtins.float]
+    escalation_rate_trend: NotRequired[Literal['increasing', 'stable', 'declining']]
+    auto_approval_rate: NotRequired[builtins.float]
+    human_override_rate: NotRequired[builtins.float]
+    mean_confidence: NotRequired[builtins.float]
+    thresholds: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryDriftMetricsThresholds]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    policy_id: NotRequired[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalPricingOptionsPriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _ExternalCoreProductPricingOptionsItemVariant5Parameters(TypedDict, total=False):
+    view_threshold: Required[builtins.float | _ExternalCoreProductPricingOptionsItemVariant5ParametersViewThresholdVariant2]
+
+class _ExternalCoreProductPricingOptionsItemVariant6Parameters(TypedDict, total=False):
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: Required[builtins.str]
+    min_points: NotRequired[builtins.float]
+
+class _ExternalCoreProductPricingOptionsItemVariant8Parameters(TypedDict, total=False):
+    type: Required[Literal['dooh']]
+    sov_percentage: NotRequired[builtins.float]
+    loop_duration_seconds: NotRequired[builtins.int]
+    min_plays_per_hour: NotRequired[builtins.int]
+    venue_package: NotRequired[builtins.str]
+    duration_hours: NotRequired[builtins.float]
+    daypart: NotRequired[builtins.str]
+    estimated_impressions: NotRequired[builtins.int]
+
+class _ExternalCoreProductPricingOptionsItemVariant9Parameters(TypedDict, total=False):
+    time_unit: Required[Literal['hour', 'day', 'week', 'month']]
+    min_duration: NotRequired[builtins.int]
+    max_duration: NotRequired[builtins.int]
+
+class _ExternalCoreForecastPoint(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    metrics: Required[_ExternalCoreForecastPointMetrics]
+
+class _ExternalCoreOutcomeMeasurementWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreDuration(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCancellationPolicyCancellationFee(TypedDict, total=False):
+    type: Required[Literal['percent_remaining', 'full_commitment', 'fixed_fee', 'none']]
+    rate: NotRequired[builtins.float]
+    amount: NotRequired[builtins.float]
+
+class _ExternalCoreGeoBreakdownSupport(TypedDict, total=False):
+    country: NotRequired[builtins.bool]
+    region: NotRequired[builtins.bool]
+    metro: NotRequired[builtins.dict[builtins.str, builtins.bool]]
+    postal_area: NotRequired[builtins.dict[builtins.str, builtins.bool]]
+
+class _ExternalCoreMeasurementWindow(TypedDict, total=False):
+    window_id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    duration_days: Required[builtins.int]
+    expected_availability_days: NotRequired[builtins.int]
+    is_guarantee_basis: NotRequired[builtins.bool]
+
+class _ExternalCoreDiagnosticIssue(TypedDict, total=False):
+    severity: Required[Literal['error', 'warning', 'info']]
+    message: Required[builtins.str]
+
+class _ExternalCoreSpecial(TypedDict, total=False):
+    name: Required[builtins.str]
+    category: NotRequired[Literal['awards', 'championship', 'concert', 'conference', 'election', 'festival', 'gala', 'holiday', 'premiere', 'product_launch', 'reunion', 'tribute']]
+    starts: NotRequired[builtins.str]
+    ends: NotRequired[builtins.str]
+
+class _ExternalCoreTalent(TypedDict, total=False):
+    role: Required[Literal['host', 'guest', 'creator', 'cast', 'narrator', 'producer', 'correspondent', 'commentator', 'analyst']]
+    name: Required[builtins.str]
+    brand_url: NotRequired[builtins.str]
+
+class _ExternalCoreAdInventoryConfig(TypedDict, total=False):
+    expected_breaks: Required[builtins.int]
+    total_ad_seconds: NotRequired[builtins.int]
+    max_ad_duration_seconds: NotRequired[builtins.int]
+    unplanned_breaks: NotRequired[builtins.bool]
+    supported_formats: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreInstallmentDeadlines(TypedDict, total=False):
+    booking_deadline: NotRequired[builtins.str]
+    cancellation_deadline: NotRequired[builtins.str]
+    material_deadlines: NotRequired[builtins.list[_ExternalCoreMaterialDeadline]]
+
+class _ExternalCoreInstallmentDerivativeOf(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    type: Required[Literal['clip', 'highlight', 'recap', 'trailer', 'bonus']]
+
+class _ExternalCoreProductTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    countries: NotRequired[builtins.list[builtins.str]]
+    uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'other']]]
+
+class _ExternalCoreProductFiltersTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreInsertionOrderTerms(TypedDict, total=False):
+    advertiser: NotRequired[builtins.str]
+    publisher: NotRequired[builtins.str]
+    total_budget: NotRequired[_ExternalCoreInsertionOrderTermsTotalBudget]
+    flight_start: NotRequired[builtins.str]
+    flight_end: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_30', 'net_60', 'net_90', 'prepaid', 'due_on_receipt']]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: NotRequired[builtins.float]
+    height: NotRequired[builtins.float]
+    min_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    responsive: NotRequired[_ExternalCoreFormatRendersItemVariant1DimensionsResponsive]
+    aspect_ratio: NotRequired[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: NotRequired[builtins.float]
+    height: NotRequired[builtins.float]
+    min_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    responsive: NotRequired[_ExternalCoreFormatRendersItemVariant2DimensionsResponsive]
+    aspect_ratio: NotRequired[builtins.str]
+
+class _ExternalCoreOverlay(TypedDict, total=False):
+    id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    visual: NotRequired[_ExternalCoreOverlayVisual]
+    bounds: Required[_ExternalCoreOverlayBounds]
+
+class _ExternalCoreRequirementsImageAssetRequirements(TypedDict, total=False):
+    min_width: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    aspect_ratio: NotRequired[builtins.str]
+    formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'avif', 'tiff', 'pdf', 'eps']]]
+    min_dpi: NotRequired[builtins.int]
+    bleed: NotRequired[_ExternalCoreRequirementsImageAssetRequirementsBleedVariant1 | _ExternalCoreRequirementsImageAssetRequirementsBleedVariant2]
+    color_space: NotRequired[Literal['rgb', 'cmyk', 'grayscale']]
+    max_file_size_kb: NotRequired[builtins.int]
+    transparency_required: NotRequired[builtins.bool]
+    animation_allowed: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_weight_grams: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsVideoAssetRequirements(TypedDict, total=False):
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    min_duration_ms: NotRequired[builtins.int]
+    max_duration_ms: NotRequired[builtins.int]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov', 'avi', 'mkv']]]
+    codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    max_file_size_kb: NotRequired[builtins.int]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    audio_required: NotRequired[builtins.bool]
+    frame_rate_type: NotRequired[Literal['constant', 'variable']]
+    scan_type: NotRequired[Literal['progressive', 'interlaced']]
+    gop_type: NotRequired[Literal['closed', 'open']]
+    min_gop_interval_seconds: NotRequired[builtins.float]
+    max_gop_interval_seconds: NotRequired[builtins.float]
+    moov_atom_position: NotRequired[Literal['start', 'end']]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'pcm', 'ac3', 'eac3', 'mp3', 'opus', 'vorbis', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo', '5.1', '7.1']]]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsAudioAssetRequirements(TypedDict, total=False):
+    min_duration_ms: NotRequired[builtins.int]
+    max_duration_ms: NotRequired[builtins.int]
+    formats: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'ogg', 'flac']]]
+    max_file_size_kb: NotRequired[builtins.int]
+    sample_rates: NotRequired[builtins.list[builtins.int]]
+    channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsTextAssetRequirements(TypedDict, total=False):
+    min_length: NotRequired[builtins.int]
+    max_length: NotRequired[builtins.int]
+    min_lines: NotRequired[builtins.int]
+    max_lines: NotRequired[builtins.int]
+    character_pattern: NotRequired[builtins.str]
+    prohibited_terms: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsMarkdownAssetRequirements(TypedDict, total=False):
+    max_length: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsHtmlAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+    sandbox: NotRequired[Literal['none', 'iframe', 'safeframe', 'fencedframe']]
+    external_resources_allowed: NotRequired[builtins.bool]
+    allowed_external_domains: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsCssAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsJavascriptAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+    module_type: NotRequired[Literal['script', 'module', 'iife']]
+    strict_mode_required: NotRequired[builtins.bool]
+    external_resources_allowed: NotRequired[builtins.bool]
+    allowed_external_domains: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsVastAssetRequirements(TypedDict, total=False):
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+
+class _ExternalCoreRequirementsDaastAssetRequirements(TypedDict, total=False):
+    daast_version: NotRequired[Literal['1.0']]
+
+class _ExternalCoreRequirementsUrlAssetRequirements(TypedDict, total=False):
+    role: NotRequired[Literal['clickthrough', 'landing_page', 'impression_tracker', 'click_tracker', 'viewability_tracker', 'third_party_tracker']]
+    protocols: NotRequired[builtins.list[Literal['https', 'http']]]
+    allowed_domains: NotRequired[builtins.list[builtins.str]]
+    max_length: NotRequired[builtins.int]
+    macro_support: NotRequired[builtins.bool]
+
+class _ExternalCoreRequirementsWebhookAssetRequirements(TypedDict, total=False):
+    methods: NotRequired[builtins.list[Literal['GET', 'POST']]]
+
+class _ExternalCoreRequirementsCatalogRequirements(TypedDict, total=False):
+    catalog_type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    required: NotRequired[builtins.bool]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    required_fields: NotRequired[builtins.list[builtins.str]]
+    feed_formats: NotRequired[builtins.list[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'custom']]]
+    offering_asset_constraints: NotRequired[builtins.list[_ExternalCoreRequirementsOfferingAssetConstraint]]
+    field_bindings: NotRequired[builtins.list[_ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant1 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant2 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3]]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant1(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['image']]
+    requirements: NotRequired[_ExternalCoreRequirementsImageAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant2(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['video']]
+    requirements: NotRequired[_ExternalCoreRequirementsVideoAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant3(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['audio']]
+    requirements: NotRequired[_ExternalCoreRequirementsAudioAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant4(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['text']]
+    requirements: NotRequired[_ExternalCoreRequirementsTextAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant5(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['markdown']]
+    requirements: NotRequired[_ExternalCoreRequirementsMarkdownAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant6(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['html']]
+    requirements: NotRequired[_ExternalCoreRequirementsHtmlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant7(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['css']]
+    requirements: NotRequired[_ExternalCoreRequirementsCssAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant8(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['javascript']]
+    requirements: NotRequired[_ExternalCoreRequirementsJavascriptAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant9(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['vast']]
+    requirements: NotRequired[_ExternalCoreRequirementsVastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant10(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['daast']]
+    requirements: NotRequired[_ExternalCoreRequirementsDaastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant11(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['url']]
+    requirements: NotRequired[_ExternalCoreRequirementsUrlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant15AssetsItemVariant12(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['webhook']]
+    requirements: NotRequired[_ExternalCoreRequirementsWebhookAssetRequirements]
+
+class _ExternalCoreFormatPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemAssignmentsAssignedPackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    assigned_date: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreUserMatchUidsItem(TypedDict, total=False):
+    type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'other']]
+    value: Required[builtins.str]
+
+class _ExternalCoreEventCustomDataContentsItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    quantity: NotRequired[builtins.int]
+    price: NotRequired[builtins.float]
+    brand: NotRequired[builtins.str]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemInput]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemInput]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentityUserShippingAddress(TypedDict, total=False):
+    street: NotRequired[builtins.str]
+    city: NotRequired[builtins.str]
+    state: NotRequired[builtins.str]
+    postal_code: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVoiceVariant2(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    voice_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVideoVariant2(TypedDict, total=False):
+    formats: NotRequired[builtins.list[builtins.str]]
+    max_duration_seconds: NotRequired[builtins.int]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesAvatarVariant2(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    avatar_id: NotRequired[builtins.str]
+
+class _ExternalA2uiComponent(TypedDict, total=False):
+    id: Required[builtins.str]
+    parentId: NotRequired[builtins.str]
+    component: Required[builtins.dict[builtins.str, builtins.dict[builtins.str, Any]]]
+
+class _SiSendMessageResponseHandoffIntentPrice(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceMemberUidsItem(TypedDict, total=False):
+    type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'other']]
+    value: Required[builtins.str]
+
+class _ExternalCoreEventSourceHealthDetail(TypedDict, total=False):
+    score: Required[builtins.float]
+    max_score: Required[builtins.float]
+    label: NotRequired[builtins.str]
+
+class _SyncGovernanceRequestAccountsItemGovernanceAgentsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemBudgetVariant1AllocationsValue(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _SyncPlansRequestPlansItemBudgetVariant2AllocationsValue(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _SyncPlansRequestPlansItemChannelsMixTargetsValue(TypedDict, total=False):
+    min_pct: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_id: Required[_ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _SyncPlansRequestPlansItemDelegationsItemBudgetLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemPortfolioTotalBudgetCap(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: Required[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostView]
+
+class _ExternalPropertyValidationResultFeaturesItemRequirement(TypedDict, total=False):
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    allowed_values: NotRequired[builtins.list[Any]]
+
+class _ExternalPropertyAuthorizationResultViolation(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+
+class _ExternalCoreProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_ExternalCoreProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoMetros(TypedDict, total=False):
+    nielsen_dma: NotRequired[builtins.bool]
+    uk_itl1: NotRequired[builtins.bool]
+    uk_itl2: NotRequired[builtins.bool]
+    eurostat_nuts2: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoPostalAreas(TypedDict, total=False):
+    us_zip: NotRequired[builtins.bool]
+    us_zip_plus_four: NotRequired[builtins.bool]
+    gb_outward: NotRequired[builtins.bool]
+    gb_full: NotRequired[builtins.bool]
+    ca_fsa: NotRequired[builtins.bool]
+    ca_full: NotRequired[builtins.bool]
+    de_plz: NotRequired[builtins.bool]
+    fr_code_postal: NotRequired[builtins.bool]
+    au_postcode: NotRequired[builtins.bool]
+    ch_plz: NotRequired[builtins.bool]
+    at_plz: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingAgeRestriction(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    verification_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingKeywordTargets(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingNegativeKeywords(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoProximity(TypedDict, total=False):
+    radius: NotRequired[builtins.bool]
+    travel_time: NotRequired[builtins.bool]
+    geometry: NotRequired[builtins.bool]
+    transport_modes: NotRequired[builtins.list[Literal['walking', 'cycling', 'driving', 'public_transport']]]
+
+class _ExternalCoreDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeVariantDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeVariantGenerationContextArtifact(TypedDict, total=False):
+    property_id: Required[_ExternalCoreIdentifier]
+    artifact_id: Required[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryDriftMetricsThresholds(TypedDict, total=False):
+    escalation_rate_max: NotRequired[builtins.float]
+    escalation_rate_min: NotRequired[builtins.float]
+    auto_approval_rate_max: NotRequired[builtins.float]
+    human_override_rate_max: NotRequired[builtins.float]
+
+class _ExternalCoreProductPricingOptionsItemVariant5ParametersViewThresholdVariant2(TypedDict, total=False):
+    duration_seconds: Required[builtins.int]
+
+class _ExternalCoreForecastPointMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_ExternalCoreForecastRange]
+    reach: NotRequired[_ExternalCoreForecastRange]
+    frequency: NotRequired[_ExternalCoreForecastRange]
+    impressions: NotRequired[_ExternalCoreForecastRange]
+    clicks: NotRequired[_ExternalCoreForecastRange]
+    spend: NotRequired[_ExternalCoreForecastRange]
+    views: NotRequired[_ExternalCoreForecastRange]
+    completed_views: NotRequired[_ExternalCoreForecastRange]
+    grps: NotRequired[_ExternalCoreForecastRange]
+    engagements: NotRequired[_ExternalCoreForecastRange]
+    follows: NotRequired[_ExternalCoreForecastRange]
+    saves: NotRequired[_ExternalCoreForecastRange]
+    profile_visits: NotRequired[_ExternalCoreForecastRange]
+    measured_impressions: NotRequired[_ExternalCoreForecastRange]
+    downloads: NotRequired[_ExternalCoreForecastRange]
+    plays: NotRequired[_ExternalCoreForecastRange]
+
+class _ExternalCoreMaterialDeadline(TypedDict, total=False):
+    stage: Required[builtins.str]
+    due_at: Required[builtins.str]
+    label: NotRequired[builtins.str]
+
+class _ExternalCoreInsertionOrderTermsTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant1DimensionsResponsive(TypedDict, total=False):
+    width: Required[builtins.bool]
+    height: Required[builtins.bool]
+
+class _ExternalCoreFormatRendersItemVariant2DimensionsResponsive(TypedDict, total=False):
+    width: Required[builtins.bool]
+    height: Required[builtins.bool]
+
+class _ExternalCoreOverlayVisual(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    light: NotRequired[builtins.str]
+    dark: NotRequired[builtins.str]
+
+class _ExternalCoreOverlayBounds(TypedDict, total=False):
+    x: Required[builtins.float]
+    y: Required[builtins.float]
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+    unit: Required[Literal['px', 'fraction', 'inches', 'cm', 'mm', 'pt']]
+
+class _ExternalCoreRequirementsImageAssetRequirementsBleedVariant1(TypedDict, total=False):
+    uniform: Required[builtins.float]
+
+class _ExternalCoreRequirementsImageAssetRequirementsBleedVariant2(TypedDict, total=False):
+    top: Required[builtins.float]
+    right: Required[builtins.float]
+    bottom: Required[builtins.float]
+    left: Required[builtins.float]
+
+class _ExternalCoreRequirementsOfferingAssetConstraint(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog']]
+    required: NotRequired[builtins.bool]
+    min_count: NotRequired[builtins.int]
+    max_count: NotRequired[builtins.int]
+    asset_requirements: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['scalar']]
+    asset_id: Required[builtins.str]
+    catalog_field: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['asset_pool']]
+    asset_id: Required[builtins.str]
+    asset_group_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['catalog_group']]
+    format_group_id: Required[builtins.str]
+    catalog_item: Required[Literal[True]]
+    per_item_bindings: NotRequired[builtins.list[_ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant1 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant2]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCatalogItemItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByCreativeItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByKeywordItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByGeoItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreForecastRange(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['scalar']]
+    asset_id: Required[builtins.str]
+    catalog_field: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['asset_pool']]
+    asset_id: Required[builtins.str]
+    asset_group_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class AcquireRightsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    pricing_option_id: builtins.str
+    buyer: _ExternalCoreBrandRef
+    campaign: _AcquireRightsRequestCampaign
+    revocation_webhook: _ExternalCorePushNotificationConfig
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        pricing_option_id: builtins.str,
+        buyer: _ExternalCoreBrandRef,
+        campaign: _AcquireRightsRequestCampaign,
+        revocation_webhook: _ExternalCorePushNotificationConfig,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcquireRightsResponse(VersionedSchemaModel):
+    rights_id: builtins.str | None
+    status: Literal['acquired'] | Literal['pending_approval'] | Literal['rejected'] | None
+    brand_id: builtins.str | None
+    terms: _ExternalBrandRightsTerms | None
+    generation_credentials: builtins.list[_ExternalCoreGenerationCredential] | None
+    restrictions: builtins.list[builtins.str] | None
+    disclosure: _AcquireRightsResponseDisclosure | None
+    approval_webhook: _ExternalCorePushNotificationConfig | None
+    usage_reporting_url: builtins.str | None
+    rights_constraint: _ExternalCoreRightsConstraint | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    detail: builtins.str | None
+    estimated_response_time: builtins.str | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        status: Literal['acquired'],
+        brand_id: builtins.str,
+        terms: _ExternalBrandRightsTerms,
+        generation_credentials: builtins.list[_ExternalCoreGenerationCredential],
+        rights_constraint: _ExternalCoreRightsConstraint,
+        restrictions: builtins.list[builtins.str] = ...,
+        disclosure: _AcquireRightsResponseDisclosure = ...,
+        approval_webhook: _ExternalCorePushNotificationConfig = ...,
+        usage_reporting_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        status: Literal['pending_approval'],
+        brand_id: builtins.str,
+        detail: builtins.str = ...,
+        estimated_response_time: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        status: Literal['rejected'],
+        brand_id: builtins.str,
+        reason: builtins.str,
+        suggestions: builtins.list[builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ActivateSignalRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    action: Literal['activate', 'deactivate']
+    signal_agent_segment_id: builtins.str
+    destinations: builtins.list[_ActivateSignalRequestDestinationsItemVariant1 | _ActivateSignalRequestDestinationsItemVariant2]
+    pricing_option_id: builtins.str | None
+    account: _ActivateSignalRequestAccountVariant1 | _ActivateSignalRequestAccountVariant2 | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        signal_agent_segment_id: builtins.str,
+        destinations: builtins.list[_ActivateSignalRequestDestinationsItemVariant1 | _ActivateSignalRequestDestinationsItemVariant2],
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        action: Literal['activate', 'deactivate'] = ...,
+        pricing_option_id: builtins.str = ...,
+        account: _ActivateSignalRequestAccountVariant1 | _ActivateSignalRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ActivateSignalResponse(VersionedSchemaModel):
+    deployments: builtins.list[_ActivateSignalResponseDeploymentsItemVariant1 | _ActivateSignalResponseDeploymentsItemVariant2] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        deployments: builtins.list[_ActivateSignalResponseDeploymentsItemVariant1 | _ActivateSignalResponseDeploymentsItemVariant2],
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    message: builtins.str | None
+    creative_manifest: _ExternalCoreCreativeManifest | None
+    creative_id: builtins.str | None
+    concept_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    package_id: builtins.str | None
+    target_format_id: _ExternalCoreFormatId | None
+    target_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    account: _BuildCreativeRequestAccountVariant1 | _BuildCreativeRequestAccountVariant2 | None
+    brand: _ExternalCoreBrandRef | None
+    quality: Literal['draft', 'production'] | None
+    item_limit: builtins.int | None
+    include_preview: builtins.bool | None
+    preview_inputs: builtins.list[_BuildCreativeRequestPreviewInputsItem] | None
+    preview_quality: Literal['draft', 'production'] | None
+    preview_output_format: Literal['url', 'html']
+    macro_values: builtins.dict[builtins.str, builtins.str] | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        message: builtins.str = ...,
+        creative_manifest: _ExternalCoreCreativeManifest = ...,
+        creative_id: builtins.str = ...,
+        concept_id: builtins.str = ...,
+        media_buy_id: builtins.str = ...,
+        package_id: builtins.str = ...,
+        target_format_id: _ExternalCoreFormatId = ...,
+        target_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        account: _BuildCreativeRequestAccountVariant1 | _BuildCreativeRequestAccountVariant2 = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        quality: Literal['draft', 'production'] = ...,
+        item_limit: builtins.int = ...,
+        include_preview: builtins.bool = ...,
+        preview_inputs: builtins.list[_BuildCreativeRequestPreviewInputsItem] = ...,
+        preview_quality: Literal['draft', 'production'] = ...,
+        preview_output_format: Literal['url', 'html'] = ...,
+        macro_values: builtins.dict[builtins.str, builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeSubmittedResponse(VersionedSchemaModel):
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeResponse(VersionedSchemaModel):
+    creative_manifest: _ExternalCoreCreativeManifest | None
+    sandbox: builtins.bool | None
+    expires_at: builtins.str | None
+    preview: _BuildCreativeResponsePreview | _BuildCreativeResponsePreview2 | None
+    preview_error: _ExternalCoreError | None
+    pricing_option_id: builtins.str | None
+    vendor_cost: builtins.float | None
+    currency: builtins.str | None
+    consumption: _ExternalCoreCreativeConsumption | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    creative_manifests: builtins.list[_ExternalCoreCreativeManifest] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        creative_manifest: _ExternalCoreCreativeManifest,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        preview: _BuildCreativeResponsePreview = ...,
+        preview_error: _ExternalCoreError = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        creative_manifests: builtins.list[_ExternalCoreCreativeManifest],
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        preview: _BuildCreativeResponsePreview2 = ...,
+        preview_error: _ExternalCoreError = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CalibrateContentRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    artifact: _ExternalContentStandardsArtifact
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        artifact: _ExternalContentStandardsArtifact,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CalibrateContentResponse(VersionedSchemaModel):
+    verdict: Literal['pass', 'fail'] | None
+    confidence: builtins.float | None
+    explanation: builtins.str | None
+    features: builtins.list[_CalibrateContentResponseFeaturesItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        verdict: Literal['pass', 'fail'],
+        confidence: builtins.float = ...,
+        explanation: builtins.str = ...,
+        features: builtins.list[_CalibrateContentResponseFeaturesItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CheckGovernanceRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    plan_id: builtins.str
+    caller: builtins.str
+    purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']
+    tool: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    governance_context: builtins.str | None
+    phase: Literal['purchase', 'modification', 'delivery']
+    planned_delivery: _ExternalCorePlannedDelivery | None
+    delivery_metrics: _CheckGovernanceRequestDeliveryMetrics | None
+    modification_summary: builtins.str | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plan_id: builtins.str,
+        caller: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services'] = ...,
+        tool: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        governance_context: builtins.str = ...,
+        phase: Literal['purchase', 'modification', 'delivery'] = ...,
+        planned_delivery: _ExternalCorePlannedDelivery = ...,
+        delivery_metrics: _CheckGovernanceRequestDeliveryMetrics = ...,
+        modification_summary: builtins.str = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CheckGovernanceResponse(VersionedSchemaModel):
+    check_id: builtins.str
+    status: Literal['approved', 'denied', 'conditions']
+    plan_id: builtins.str
+    explanation: builtins.str
+    findings: builtins.list[_CheckGovernanceResponseFindingsItem] | None
+    conditions: builtins.list[_CheckGovernanceResponseConditionsItem] | None
+    expires_at: builtins.str | None
+    next_check: builtins.str | None
+    categories_evaluated: builtins.list[builtins.str] | None
+    policies_evaluated: builtins.list[builtins.str] | None
+    mode: Literal['audit', 'advisory', 'enforce'] | None
+    governance_context: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        check_id: builtins.str,
+        status: Literal['approved', 'denied', 'conditions'],
+        plan_id: builtins.str,
+        explanation: builtins.str,
+        findings: builtins.list[_CheckGovernanceResponseFindingsItem] = ...,
+        conditions: builtins.list[_CheckGovernanceResponseConditionsItem] = ...,
+        expires_at: builtins.str = ...,
+        next_check: builtins.str = ...,
+        categories_evaluated: builtins.list[builtins.str] = ...,
+        policies_evaluated: builtins.list[builtins.str] = ...,
+        mode: Literal['audit', 'advisory', 'enforce'] = ...,
+        governance_context: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ComplyTestControllerRequest(VersionedSchemaModel):
+    scenario: Literal['list_scenarios', 'force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_create_media_buy_arm', 'force_task_completion', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend', 'seed_product', 'seed_pricing_option', 'seed_creative', 'seed_plan', 'seed_media_buy', 'seed_creative_format']
+    params: _ComplyTestControllerRequestParams | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        scenario: Literal['list_scenarios', 'force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_create_media_buy_arm', 'force_task_completion', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend', 'seed_product', 'seed_pricing_option', 'seed_creative', 'seed_plan', 'seed_media_buy', 'seed_creative_format'],
+        params: _ComplyTestControllerRequestParams = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ComplyTestControllerResponse(VersionedSchemaModel):
+    success: Literal[True] | Literal[False]
+    scenarios: builtins.list[Literal['force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_create_media_buy_arm', 'force_task_completion', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend', 'seed_product', 'seed_pricing_option', 'seed_creative', 'seed_plan', 'seed_media_buy', 'seed_creative_format']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    previous_state: builtins.str | None
+    current_state: builtins.str | builtins.str | None
+    message: builtins.str | None
+    simulated: builtins.dict[builtins.str, Any] | None
+    cumulative: builtins.dict[builtins.str, Any] | None
+    forced: _ComplyTestControllerResponseForced | None
+    error: Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'INTERNAL_ERROR'] | None
+    error_detail: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        scenarios: builtins.list[Literal['force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_create_media_buy_arm', 'force_task_completion', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend', 'seed_product', 'seed_pricing_option', 'seed_creative', 'seed_plan', 'seed_media_buy', 'seed_creative_format']],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        previous_state: builtins.str,
+        current_state: builtins.str,
+        message: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        simulated: builtins.dict[builtins.str, Any],
+        cumulative: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        forced: _ComplyTestControllerResponseForced,
+        message: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        message: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[False],
+        error: Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'INTERNAL_ERROR'],
+        error_detail: builtins.str = ...,
+        current_state: builtins.str | None = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ContextMatchRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    type: Literal['context_match_request']
+    protocol_version: builtins.str
+    request_id: builtins.str
+    property_rid: builtins.str
+    property_id: builtins.str | None
+    property_type: Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']
+    placement_id: builtins.str
+    artifact: _ExternalContentStandardsArtifact | None
+    artifact_refs: builtins.list[_ContextMatchRequestArtifactRefsItem] | None
+    geo: _ContextMatchRequestGeo | None
+    context_signals: _ContextMatchRequestContextSignals | None
+    package_ids: builtins.list[builtins.str] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['context_match_request'],
+        request_id: builtins.str,
+        property_rid: builtins.str,
+        property_type: Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant'],
+        placement_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        protocol_version: builtins.str = ...,
+        property_id: builtins.str = ...,
+        artifact: _ExternalContentStandardsArtifact = ...,
+        artifact_refs: builtins.list[_ContextMatchRequestArtifactRefsItem] = ...,
+        geo: _ContextMatchRequestGeo = ...,
+        context_signals: _ContextMatchRequestContextSignals = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+    ) -> None: ...
+
+class ContextMatchResponse(VersionedSchemaModel):
+    type: Literal['context_match_response']
+    request_id: builtins.str
+    offers: builtins.list[_ExternalTmpOffer]
+    cache_ttl: builtins.int | None
+    signals: _ContextMatchResponseSignals | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['context_match_response'],
+        request_id: builtins.str,
+        offers: builtins.list[_ExternalTmpOffer],
+        cache_ttl: builtins.int = ...,
+        signals: _ContextMatchResponseSignals = ...,
+    ) -> None: ...
+
+class CreateCollectionListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _CreateCollectionListRequestAccountVariant1 | _CreateCollectionListRequestAccountVariant2 | None
+    name: builtins.str
+    description: builtins.str | None
+    base_collections: builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1 | _CreateCollectionListRequestBaseCollectionsItemVariant2 | _CreateCollectionListRequestBaseCollectionsItemVariant3] | None
+    filters: _ExternalCollectionCollectionListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _CreateCollectionListRequestAccountVariant1 | _CreateCollectionListRequestAccountVariant2 = ...,
+        description: builtins.str = ...,
+        base_collections: builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1 | _CreateCollectionListRequestBaseCollectionsItemVariant2 | _CreateCollectionListRequestBaseCollectionsItemVariant3] = ...,
+        filters: _ExternalCollectionCollectionListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateCollectionListResponse(VersionedSchemaModel):
+    list: _ExternalCollectionCollectionList
+    auth_token: builtins.str
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list: _ExternalCollectionCollectionList,
+        auth_token: builtins.str,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateContentStandardsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    scope: _CreateContentStandardsRequestScope
+    registry_policy_ids: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _CreateContentStandardsRequestCalibrationExemplars | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        scope: _CreateContentStandardsRequestScope,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        registry_policy_ids: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _CreateContentStandardsRequestCalibrationExemplars = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateContentStandardsResponse(VersionedSchemaModel):
+    standards_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    conflicting_standards_id: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        conflicting_standards_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    plan_id: builtins.str | None
+    account: _CreateMediaBuyRequestAccountVariant1 | _CreateMediaBuyRequestAccountVariant2
+    proposal_id: builtins.str | None
+    total_budget: _CreateMediaBuyRequestTotalBudget | None
+    packages: builtins.list[_ExternalMediaBuyPackageRequest] | None
+    brand: _ExternalCoreBrandRef
+    advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    io_acceptance: _CreateMediaBuyRequestIoAcceptance | None
+    po_number: builtins.str | None
+    agency_estimate_number: builtins.str | None
+    start_time: Literal['asap'] | builtins.str
+    end_time: builtins.str
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    artifact_webhook: _CreateMediaBuyRequestArtifactWebhook | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _CreateMediaBuyRequestAccountVariant1 | _CreateMediaBuyRequestAccountVariant2,
+        brand: _ExternalCoreBrandRef,
+        start_time: Literal['asap'] | builtins.str,
+        end_time: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        plan_id: builtins.str = ...,
+        proposal_id: builtins.str = ...,
+        total_budget: _CreateMediaBuyRequestTotalBudget = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageRequest] = ...,
+        advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        io_acceptance: _CreateMediaBuyRequestIoAcceptance = ...,
+        po_number: builtins.str = ...,
+        agency_estimate_number: builtins.str = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        artifact_webhook: _CreateMediaBuyRequestArtifactWebhook = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuySubmittedResponse(VersionedSchemaModel):
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyResponse(VersionedSchemaModel):
+    media_buy_id: builtins.str | None
+    account: _ExternalCoreAccount | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | Literal['submitted'] | None
+    confirmed_at: builtins.str | None
+    creative_deadline: builtins.str | None
+    revision: builtins.int | None
+    valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_packages', 'sync_creatives']] | None
+    packages: builtins.list[_ExternalCorePackage] | None
+    planned_delivery: _ExternalCorePlannedDelivery | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        packages: builtins.list[_ExternalCorePackage],
+        account: _ExternalCoreAccount = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        confirmed_at: builtins.str = ...,
+        creative_deadline: builtins.str = ...,
+        revision: builtins.int = ...,
+        valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_packages', 'sync_creatives']] = ...,
+        planned_delivery: _ExternalCorePlannedDelivery = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreatePropertyListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _CreatePropertyListRequestAccountVariant1 | _CreatePropertyListRequestAccountVariant2 | None
+    name: builtins.str
+    description: builtins.str | None
+    base_properties: builtins.list[_CreatePropertyListRequestBasePropertiesItemVariant1 | _CreatePropertyListRequestBasePropertiesItemVariant2 | _CreatePropertyListRequestBasePropertiesItemVariant3] | None
+    filters: _ExternalPropertyPropertyListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _CreatePropertyListRequestAccountVariant1 | _CreatePropertyListRequestAccountVariant2 = ...,
+        description: builtins.str = ...,
+        base_properties: builtins.list[_CreatePropertyListRequestBasePropertiesItemVariant1 | _CreatePropertyListRequestBasePropertiesItemVariant2 | _CreatePropertyListRequestBasePropertiesItemVariant3] = ...,
+        filters: _ExternalPropertyPropertyListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreatePropertyListResponse(VersionedSchemaModel):
+    list: _ExternalPropertyPropertyList
+    auth_token: builtins.str
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list: _ExternalPropertyPropertyList,
+        auth_token: builtins.str,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreativeApprovalRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    creative_id: builtins.str | None
+    creative_url: builtins.str
+    creative_format: _ExternalCoreFormatId | None
+    description: builtins.str | None
+    metadata: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        creative_url: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        creative_id: builtins.str = ...,
+        creative_format: _ExternalCoreFormatId = ...,
+        description: builtins.str = ...,
+        metadata: builtins.dict[builtins.str, Any] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreativeApprovalResponse(VersionedSchemaModel):
+    status: Literal['approved'] | Literal['rejected'] | Literal['pending_review'] | None
+    rights_id: builtins.str | None
+    creative_id: builtins.str | None
+    creative_url: builtins.str | None
+    approved_at: builtins.str | None
+    conditions: builtins.list[builtins.str] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    estimated_response_time: builtins.str | None
+    status_url: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['approved'],
+        rights_id: builtins.str,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        approved_at: builtins.str = ...,
+        conditions: builtins.list[builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['rejected'],
+        rights_id: builtins.str,
+        reason: builtins.str,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['pending_review'],
+        rights_id: builtins.str,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        estimated_response_time: builtins.str = ...,
+        status_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeleteCollectionListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _DeleteCollectionListRequestAccountVariant1 | _DeleteCollectionListRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _DeleteCollectionListRequestAccountVariant1 | _DeleteCollectionListRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeleteCollectionListResponse(VersionedSchemaModel):
+    deleted: builtins.bool
+    list_id: builtins.str
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        deleted: builtins.bool,
+        list_id: builtins.str,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeletePropertyListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _DeletePropertyListRequestAccountVariant1 | _DeletePropertyListRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _DeletePropertyListRequestAccountVariant1 | _DeletePropertyListRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeletePropertyListResponse(VersionedSchemaModel):
+    deleted: builtins.bool
+    list_id: builtins.str
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        deleted: builtins.bool,
+        list_id: builtins.str,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAccountFinancialsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _GetAccountFinancialsRequestAccountVariant1 | _GetAccountFinancialsRequestAccountVariant2
+    period: _ExternalCoreDateRange | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _GetAccountFinancialsRequestAccountVariant1 | _GetAccountFinancialsRequestAccountVariant2,
+        adcp_major_version: builtins.int = ...,
+        period: _ExternalCoreDateRange = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAccountFinancialsResponse(VersionedSchemaModel):
+    account: _GetAccountFinancialsResponseAccountVariant1 | _GetAccountFinancialsResponseAccountVariant2 | None
+    currency: builtins.str | None
+    period: _ExternalCoreDateRange | None
+    timezone: builtins.str | None
+    spend: _GetAccountFinancialsResponseSpend | None
+    credit: _GetAccountFinancialsResponseCredit | None
+    balance: _GetAccountFinancialsResponseBalance | None
+    payment_status: Literal['current', 'past_due', 'suspended'] | None
+    payment_terms: Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] | None
+    invoices: builtins.list[_GetAccountFinancialsResponseInvoicesItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _GetAccountFinancialsResponseAccountVariant1 | _GetAccountFinancialsResponseAccountVariant2,
+        currency: builtins.str,
+        period: _ExternalCoreDateRange,
+        timezone: builtins.str,
+        spend: _GetAccountFinancialsResponseSpend = ...,
+        credit: _GetAccountFinancialsResponseCredit = ...,
+        balance: _GetAccountFinancialsResponseBalance = ...,
+        payment_status: Literal['current', 'past_due', 'suspended'] = ...,
+        payment_terms: Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] = ...,
+        invoices: builtins.list[_GetAccountFinancialsResponseInvoicesItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAdcpCapabilitiesRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAdcpCapabilitiesResponse(VersionedSchemaModel):
+    adcp: _GetAdcpCapabilitiesResponseAdcp
+    supported_protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand']]
+    account: _GetAdcpCapabilitiesResponseAccount | None
+    media_buy: _GetAdcpCapabilitiesResponseMediaBuy | None
+    signals: _GetAdcpCapabilitiesResponseSignals | None
+    governance: _GetAdcpCapabilitiesResponseGovernance | None
+    sponsored_intelligence: _GetAdcpCapabilitiesResponseSponsoredIntelligence | None
+    brand: _GetAdcpCapabilitiesResponseBrand | None
+    creative: _GetAdcpCapabilitiesResponseCreative | None
+    request_signing: _GetAdcpCapabilitiesResponseRequestSigning | None
+    webhook_signing: _GetAdcpCapabilitiesResponseWebhookSigning | None
+    identity: _GetAdcpCapabilitiesResponseIdentity | None
+    compliance_testing: _GetAdcpCapabilitiesResponseComplianceTesting | None
+    specialisms: builtins.list[Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests']] | None
+    extensions_supported: builtins.list[builtins.str] | None
+    experimental_features: builtins.list[builtins.str] | None
+    last_updated: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp: _GetAdcpCapabilitiesResponseAdcp,
+        supported_protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand']],
+        account: _GetAdcpCapabilitiesResponseAccount = ...,
+        media_buy: _GetAdcpCapabilitiesResponseMediaBuy = ...,
+        signals: _GetAdcpCapabilitiesResponseSignals = ...,
+        governance: _GetAdcpCapabilitiesResponseGovernance = ...,
+        sponsored_intelligence: _GetAdcpCapabilitiesResponseSponsoredIntelligence = ...,
+        brand: _GetAdcpCapabilitiesResponseBrand = ...,
+        creative: _GetAdcpCapabilitiesResponseCreative = ...,
+        request_signing: _GetAdcpCapabilitiesResponseRequestSigning = ...,
+        webhook_signing: _GetAdcpCapabilitiesResponseWebhookSigning = ...,
+        identity: _GetAdcpCapabilitiesResponseIdentity = ...,
+        compliance_testing: _GetAdcpCapabilitiesResponseComplianceTesting = ...,
+        specialisms: builtins.list[Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests']] = ...,
+        extensions_supported: builtins.list[builtins.str] = ...,
+        experimental_features: builtins.list[builtins.str] = ...,
+        last_updated: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetBrandIdentityRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    brand_id: builtins.str
+    fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
+    use_case: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        brand_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] = ...,
+        use_case: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetBrandIdentityResponse(VersionedSchemaModel):
+    brand_id: builtins.str | None
+    house: _GetBrandIdentityResponseHouse | None
+    names: builtins.list[builtins.dict[builtins.str, builtins.str]] | None
+    description: builtins.str | None
+    industries: builtins.list[builtins.str] | None
+    keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] | None
+    logos: builtins.list[_GetBrandIdentityResponseLogosItem] | None
+    colors: _GetBrandIdentityResponseColors | None
+    fonts: _GetBrandIdentityResponseFonts | None
+    visual_guidelines: builtins.dict[builtins.str, Any] | None
+    tone: _GetBrandIdentityResponseTone | None
+    tagline: builtins.str | builtins.list[builtins.dict[builtins.str, builtins.str]] | None
+    voice_synthesis: _GetBrandIdentityResponseVoiceSynthesis | None
+    assets: builtins.list[_GetBrandIdentityResponseAssetsItem] | None
+    rights: _GetBrandIdentityResponseRights | None
+    available_fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        brand_id: builtins.str,
+        house: _GetBrandIdentityResponseHouse,
+        names: builtins.list[builtins.dict[builtins.str, builtins.str]],
+        description: builtins.str = ...,
+        industries: builtins.list[builtins.str] = ...,
+        keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] = ...,
+        logos: builtins.list[_GetBrandIdentityResponseLogosItem] = ...,
+        colors: _GetBrandIdentityResponseColors = ...,
+        fonts: _GetBrandIdentityResponseFonts = ...,
+        visual_guidelines: builtins.dict[builtins.str, Any] = ...,
+        tone: _GetBrandIdentityResponseTone = ...,
+        tagline: builtins.str | builtins.list[builtins.dict[builtins.str, builtins.str]] = ...,
+        voice_synthesis: _GetBrandIdentityResponseVoiceSynthesis = ...,
+        assets: builtins.list[_GetBrandIdentityResponseAssetsItem] = ...,
+        rights: _GetBrandIdentityResponseRights = ...,
+        available_fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCollectionListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _GetCollectionListRequestAccountVariant1 | _GetCollectionListRequestAccountVariant2 | None
+    resolve: builtins.bool
+    pagination: _GetCollectionListRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _GetCollectionListRequestAccountVariant1 | _GetCollectionListRequestAccountVariant2 = ...,
+        resolve: builtins.bool = ...,
+        pagination: _GetCollectionListRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCollectionListResponse(VersionedSchemaModel):
+    list: _ExternalCollectionCollectionList
+    collections: builtins.list[_GetCollectionListResponseCollectionsItem] | None
+    pagination: _ExternalCorePaginationResponse | None
+    resolved_at: builtins.str | None
+    cache_valid_until: builtins.str | None
+    coverage_gaps: builtins.dict[builtins.str, builtins.list[_GetCollectionListResponseCoverageGapsValueItem]] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list: _ExternalCollectionCollectionList,
+        collections: builtins.list[_GetCollectionListResponseCollectionsItem] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        resolved_at: builtins.str = ...,
+        cache_valid_until: builtins.str = ...,
+        coverage_gaps: builtins.dict[builtins.str, builtins.list[_GetCollectionListResponseCoverageGapsValueItem]] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetContentStandardsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetContentStandardsResponse(VersionedSchemaModel):
+    standards_id: builtins.str | None
+    name: builtins.str | None
+    countries_all: builtins.list[builtins.str] | None
+    channels_any: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None
+    languages_any: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _GetContentStandardsResponseCalibrationExemplars | None
+    pricing_options: builtins.list[_GetContentStandardsResponsePricingOptionsItemVariant1 | _GetContentStandardsResponsePricingOptionsItemVariant2 | _GetContentStandardsResponsePricingOptionsItemVariant3 | _GetContentStandardsResponsePricingOptionsItemVariant4 | _GetContentStandardsResponsePricingOptionsItemVariant5] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    context: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        name: builtins.str = ...,
+        countries_all: builtins.list[builtins.str] = ...,
+        channels_any: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] = ...,
+        languages_any: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _GetContentStandardsResponseCalibrationExemplars = ...,
+        pricing_options: builtins.list[_GetContentStandardsResponsePricingOptionsItemVariant1 | _GetContentStandardsResponsePricingOptionsItemVariant2 | _GetContentStandardsResponsePricingOptionsItemVariant3 | _GetContentStandardsResponsePricingOptionsItemVariant4 | _GetContentStandardsResponsePricingOptionsItemVariant5] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeDeliveryRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _GetCreativeDeliveryRequestAccountVariant1 | _GetCreativeDeliveryRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    creative_ids: builtins.list[builtins.str] | None
+    start_date: builtins.str | None
+    end_date: builtins.str | None
+    max_variants: builtins.int | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        account: _GetCreativeDeliveryRequestAccountVariant1 | _GetCreativeDeliveryRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        creative_ids: builtins.list[builtins.str] = ...,
+        start_date: builtins.str = ...,
+        end_date: builtins.str = ...,
+        max_variants: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeDeliveryResponse(VersionedSchemaModel):
+    account_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    currency: builtins.str
+    reporting_period: _GetCreativeDeliveryResponseReportingPeriod
+    creatives: builtins.list[_GetCreativeDeliveryResponseCreativesItem]
+    pagination: _GetCreativeDeliveryResponsePagination | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        currency: builtins.str,
+        reporting_period: _GetCreativeDeliveryResponseReportingPeriod,
+        creatives: builtins.list[_GetCreativeDeliveryResponseCreativesItem],
+        account_id: builtins.str = ...,
+        media_buy_id: builtins.str = ...,
+        pagination: _GetCreativeDeliveryResponsePagination = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeFeaturesRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    creative_manifest: _ExternalCoreCreativeManifest
+    feature_ids: builtins.list[builtins.str] | None
+    account: _GetCreativeFeaturesRequestAccountVariant1 | _GetCreativeFeaturesRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        creative_manifest: _ExternalCoreCreativeManifest,
+        adcp_major_version: builtins.int = ...,
+        feature_ids: builtins.list[builtins.str] = ...,
+        account: _GetCreativeFeaturesRequestAccountVariant1 | _GetCreativeFeaturesRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeFeaturesResponse(VersionedSchemaModel):
+    results: builtins.list[_ExternalCreativeCreativeFeatureResult] | None
+    detail_url: builtins.str | None
+    pricing_option_id: builtins.str | None
+    vendor_cost: builtins.float | None
+    currency: builtins.str | None
+    consumption: _ExternalCoreCreativeConsumption | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        results: builtins.list[_ExternalCreativeCreativeFeatureResult],
+        detail_url: builtins.str = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyArtifactsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuyArtifactsRequestAccountVariant1 | _GetMediaBuyArtifactsRequestAccountVariant2 | None
+    media_buy_id: builtins.str
+    package_ids: builtins.list[builtins.str] | None
+    failures_only: builtins.bool
+    time_range: _GetMediaBuyArtifactsRequestTimeRange | None
+    pagination: _GetMediaBuyArtifactsRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuyArtifactsRequestAccountVariant1 | _GetMediaBuyArtifactsRequestAccountVariant2 = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+        failures_only: builtins.bool = ...,
+        time_range: _GetMediaBuyArtifactsRequestTimeRange = ...,
+        pagination: _GetMediaBuyArtifactsRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyArtifactsResponse(VersionedSchemaModel):
+    media_buy_id: builtins.str | None
+    artifacts: builtins.list[_GetMediaBuyArtifactsResponseArtifactsItem] | None
+    collection_info: _GetMediaBuyArtifactsResponseCollectionInfo | None
+    pagination: _ExternalCorePaginationResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        artifacts: builtins.list[_GetMediaBuyArtifactsResponseArtifactsItem],
+        collection_info: _GetMediaBuyArtifactsResponseCollectionInfo = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyDeliveryRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuyDeliveryRequestAccountVariant1 | _GetMediaBuyDeliveryRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None
+    start_date: builtins.str | None
+    end_date: builtins.str | None
+    include_package_daily_breakdown: builtins.bool
+    attribution_window: _GetMediaBuyDeliveryRequestAttributionWindow | None
+    reporting_dimensions: _GetMediaBuyDeliveryRequestReportingDimensions | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuyDeliveryRequestAccountVariant1 | _GetMediaBuyDeliveryRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] = ...,
+        start_date: builtins.str = ...,
+        end_date: builtins.str = ...,
+        include_package_daily_breakdown: builtins.bool = ...,
+        attribution_window: _GetMediaBuyDeliveryRequestAttributionWindow = ...,
+        reporting_dimensions: _GetMediaBuyDeliveryRequestReportingDimensions = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyDeliveryResponse(VersionedSchemaModel):
+    notification_type: Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] | None
+    partial_data: builtins.bool | None
+    unavailable_count: builtins.int | None
+    sequence_number: builtins.int | None
+    next_expected_at: builtins.str | None
+    reporting_period: _GetMediaBuyDeliveryResponseReportingPeriod
+    currency: builtins.str
+    attribution_window: _ExternalCoreAttributionWindow | None
+    aggregated_totals: _GetMediaBuyDeliveryResponseAggregatedTotals | None
+    media_buy_deliveries: builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reporting_period: _GetMediaBuyDeliveryResponseReportingPeriod,
+        currency: builtins.str,
+        media_buy_deliveries: builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem],
+        notification_type: Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] = ...,
+        partial_data: builtins.bool = ...,
+        unavailable_count: builtins.int = ...,
+        sequence_number: builtins.int = ...,
+        next_expected_at: builtins.str = ...,
+        attribution_window: _ExternalCoreAttributionWindow = ...,
+        aggregated_totals: _GetMediaBuyDeliveryResponseAggregatedTotals = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuysRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuysRequestAccountVariant1 | _GetMediaBuysRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None
+    include_snapshot: builtins.bool
+    include_history: builtins.int
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuysRequestAccountVariant1 | _GetMediaBuysRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] = ...,
+        include_snapshot: builtins.bool = ...,
+        include_history: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuysResponse(VersionedSchemaModel):
+    media_buys: builtins.list[_GetMediaBuysResponseMediaBuysItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buys: builtins.list[_GetMediaBuysResponseMediaBuysItem],
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPlanAuditLogsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    plan_ids: builtins.list[builtins.str] | None
+    portfolio_plan_ids: builtins.list[builtins.str] | None
+    governance_contexts: builtins.list[builtins.str] | None
+    purchase_types: builtins.list[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] | None
+    include_entries: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        plan_ids: builtins.list[builtins.str] = ...,
+        portfolio_plan_ids: builtins.list[builtins.str] = ...,
+        governance_contexts: builtins.list[builtins.str] = ...,
+        purchase_types: builtins.list[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] = ...,
+        include_entries: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPlanAuditLogsResponse(VersionedSchemaModel):
+    plans: builtins.list[_GetPlanAuditLogsResponsePlansItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plans: builtins.list[_GetPlanAuditLogsResponsePlansItem],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] | None
+    partial_results: builtins.list[_ExternalCoreProduct] | None
+    suggestions: builtins.list[builtins.str] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] = ...,
+        partial_results: builtins.list[_ExternalCoreProduct] = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    buying_mode: Literal['brief', 'wholesale', 'refine']
+    brief: builtins.str | None
+    refine: builtins.list[_GetProductsRequestRefineItemVariant1 | _GetProductsRequestRefineItemVariant2 | _GetProductsRequestRefineItemVariant3] | None
+    brand: _ExternalCoreBrandRef | None
+    catalog: _ExternalCoreCatalog | None
+    account: _GetProductsRequestAccountVariant1 | _GetProductsRequestAccountVariant2 | None
+    preferred_delivery_types: builtins.list[Literal['guaranteed', 'non_guaranteed']] | None
+    filters: _ExternalCoreProductFilters | None
+    property_list: _ExternalCorePropertyListRef | None
+    fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'format_ids', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] | None
+    time_budget: _GetProductsRequestTimeBudget | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    required_policies: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        buying_mode: Literal['brief', 'wholesale', 'refine'],
+        adcp_major_version: builtins.int = ...,
+        brief: builtins.str = ...,
+        refine: builtins.list[_GetProductsRequestRefineItemVariant1 | _GetProductsRequestRefineItemVariant2 | _GetProductsRequestRefineItemVariant3] = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        catalog: _ExternalCoreCatalog = ...,
+        account: _GetProductsRequestAccountVariant1 | _GetProductsRequestAccountVariant2 = ...,
+        preferred_delivery_types: builtins.list[Literal['guaranteed', 'non_guaranteed']] = ...,
+        filters: _ExternalCoreProductFilters = ...,
+        property_list: _ExternalCorePropertyListRef = ...,
+        fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'format_ids', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] = ...,
+        time_budget: _GetProductsRequestTimeBudget = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        required_policies: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsSubmittedResponse(VersionedSchemaModel):
+    estimated_completion: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        estimated_completion: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsResponse(VersionedSchemaModel):
+    products: builtins.list[_ExternalCoreProduct]
+    proposals: builtins.list[_ExternalCoreProposal] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    property_list_applied: builtins.bool | None
+    catalog_applied: builtins.bool | None
+    refinement_applied: builtins.list[_GetProductsResponseRefinementAppliedItemVariant1 | _GetProductsResponseRefinementAppliedItemVariant2 | _GetProductsResponseRefinementAppliedItemVariant3] | None
+    incomplete: builtins.list[_GetProductsResponseIncompleteItem] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        products: builtins.list[_ExternalCoreProduct],
+        proposals: builtins.list[_ExternalCoreProposal] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        property_list_applied: builtins.bool = ...,
+        catalog_applied: builtins.bool = ...,
+        refinement_applied: builtins.list[_GetProductsResponseRefinementAppliedItemVariant1 | _GetProductsResponseRefinementAppliedItemVariant2 | _GetProductsResponseRefinementAppliedItemVariant3] = ...,
+        incomplete: builtins.list[_GetProductsResponseIncompleteItem] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPropertyListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _GetPropertyListRequestAccountVariant1 | _GetPropertyListRequestAccountVariant2 | None
+    resolve: builtins.bool
+    pagination: _GetPropertyListRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _GetPropertyListRequestAccountVariant1 | _GetPropertyListRequestAccountVariant2 = ...,
+        resolve: builtins.bool = ...,
+        pagination: _GetPropertyListRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPropertyListResponse(VersionedSchemaModel):
+    list: _ExternalPropertyPropertyList
+    identifiers: builtins.list[_ExternalCoreIdentifier] | None
+    pagination: _ExternalCorePaginationResponse | None
+    resolved_at: builtins.str | None
+    cache_valid_until: builtins.str | None
+    coverage_gaps: builtins.dict[builtins.str, builtins.list[_ExternalCoreIdentifier]] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list: _ExternalPropertyPropertyList,
+        identifiers: builtins.list[_ExternalCoreIdentifier] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        resolved_at: builtins.str = ...,
+        cache_valid_until: builtins.str = ...,
+        coverage_gaps: builtins.dict[builtins.str, builtins.list[_ExternalCoreIdentifier]] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetRightsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    query: builtins.str
+    uses: builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]
+    buyer_brand: _ExternalCoreBrandRef | None
+    countries: builtins.list[builtins.str] | None
+    brand_id: builtins.str | None
+    right_type: Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] | None
+    include_excluded: builtins.bool
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query: builtins.str,
+        uses: builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']],
+        adcp_major_version: builtins.int = ...,
+        buyer_brand: _ExternalCoreBrandRef = ...,
+        countries: builtins.list[builtins.str] = ...,
+        brand_id: builtins.str = ...,
+        right_type: Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] = ...,
+        include_excluded: builtins.bool = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetRightsResponse(VersionedSchemaModel):
+    rights: builtins.list[_GetRightsResponseRightsItem] | None
+    excluded: builtins.list[_GetRightsResponseExcludedItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights: builtins.list[_GetRightsResponseRightsItem],
+        excluded: builtins.list[_GetRightsResponseExcludedItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _GetSignalsRequestAccountVariant1 | _GetSignalsRequestAccountVariant2 | None
+    signal_spec: builtins.str | None
+    signal_ids: builtins.list[_GetSignalsRequestSignalIdsItemVariant1 | _GetSignalsRequestSignalIdsItemVariant2] | None
+    destinations: builtins.list[_GetSignalsRequestDestinationsItemVariant1 | _GetSignalsRequestDestinationsItemVariant2] | None
+    countries: builtins.list[builtins.str] | None
+    filters: _ExternalCoreSignalFilters | None
+    max_results: builtins.int | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        account: _GetSignalsRequestAccountVariant1 | _GetSignalsRequestAccountVariant2 = ...,
+        signal_spec: builtins.str = ...,
+        signal_ids: builtins.list[_GetSignalsRequestSignalIdsItemVariant1 | _GetSignalsRequestSignalIdsItemVariant2] = ...,
+        destinations: builtins.list[_GetSignalsRequestDestinationsItemVariant1 | _GetSignalsRequestDestinationsItemVariant2] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        filters: _ExternalCoreSignalFilters = ...,
+        max_results: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsResponse(VersionedSchemaModel):
+    signals: builtins.list[_GetSignalsResponseSignalsItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        signals: builtins.list[_GetSignalsResponseSignalsItem],
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class IdentityMatchRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    type: Literal['identity_match_request']
+    protocol_version: builtins.str
+    request_id: builtins.str
+    seller_agent_url: builtins.str
+    identities: builtins.list[_IdentityMatchRequestIdentitiesItem]
+    consent: _IdentityMatchRequestConsent | None
+    package_ids: builtins.list[builtins.str] | None
+    country: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['identity_match_request'],
+        request_id: builtins.str,
+        seller_agent_url: builtins.str,
+        identities: builtins.list[_IdentityMatchRequestIdentitiesItem],
+        adcp_major_version: builtins.int = ...,
+        protocol_version: builtins.str = ...,
+        consent: _IdentityMatchRequestConsent = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+        country: builtins.str = ...,
+    ) -> None: ...
+
+class IdentityMatchResponse(VersionedSchemaModel):
+    type: Literal['identity_match_response']
+    request_id: builtins.str
+    eligible_package_ids: builtins.list[builtins.str]
+    ttl_sec: builtins.int
+    tmpx: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['identity_match_response'],
+        request_id: builtins.str,
+        eligible_package_ids: builtins.list[builtins.str],
+        ttl_sec: builtins.int,
+        tmpx: builtins.str = ...,
+    ) -> None: ...
+
+class ListAccountsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    status: Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] | None
+    pagination: _ExternalCorePaginationRequest | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        status: Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListAccountsResponse(VersionedSchemaModel):
+    accounts: builtins.list[_ExternalCoreAccount]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        accounts: builtins.list[_ExternalCoreAccount],
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCollectionListsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _ListCollectionListsRequestAccountVariant1 | _ListCollectionListsRequestAccountVariant2 | None
+    name_contains: builtins.str | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        account: _ListCollectionListsRequestAccountVariant1 | _ListCollectionListsRequestAccountVariant2 = ...,
+        name_contains: builtins.str = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCollectionListsResponse(VersionedSchemaModel):
+    lists: builtins.list[_ExternalCollectionCollectionList]
+    pagination: _ExternalCorePaginationResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        lists: builtins.list[_ExternalCollectionCollectionList],
+        pagination: _ExternalCorePaginationResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListContentStandardsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    channels: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None
+    languages: builtins.list[builtins.str] | None
+    countries: builtins.list[builtins.str] | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        channels: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] = ...,
+        languages: builtins.list[builtins.str] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListContentStandardsResponse(VersionedSchemaModel):
+    standards: builtins.list[_ExternalContentStandardsContentStandards] | None
+    pagination: _ExternalCorePaginationResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards: builtins.list[_ExternalContentStandardsContentStandards],
+        pagination: _ExternalCorePaginationResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativeFormatsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    format_ids: builtins.list[_ExternalCoreFormatId] | None
+    type: Literal['audio', 'video', 'display', 'dooh'] | None
+    asset_types: builtins.list[Literal['image', 'video', 'audio', 'text', 'html', 'javascript', 'url']] | None
+    max_width: builtins.int | None
+    max_height: builtins.int | None
+    min_width: builtins.int | None
+    min_height: builtins.int | None
+    is_responsive: builtins.bool | None
+    name_search: builtins.str | None
+    wcag_level: Literal['A', 'AA', 'AAA'] | None
+    disclosure_positions: builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] | None
+    disclosure_persistence: builtins.list[Literal['continuous', 'initial', 'flexible']] | None
+    output_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    input_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    include_pricing: builtins.bool
+    account: _ListCreativeFormatsRequestAccountVariant1 | _ListCreativeFormatsRequestAccountVariant2 | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        type: Literal['audio', 'video', 'display', 'dooh'] = ...,
+        asset_types: builtins.list[Literal['image', 'video', 'audio', 'text', 'html', 'javascript', 'url']] = ...,
+        max_width: builtins.int = ...,
+        max_height: builtins.int = ...,
+        min_width: builtins.int = ...,
+        min_height: builtins.int = ...,
+        is_responsive: builtins.bool = ...,
+        name_search: builtins.str = ...,
+        wcag_level: Literal['A', 'AA', 'AAA'] = ...,
+        disclosure_positions: builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] = ...,
+        disclosure_persistence: builtins.list[Literal['continuous', 'initial', 'flexible']] = ...,
+        output_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        input_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        include_pricing: builtins.bool = ...,
+        account: _ListCreativeFormatsRequestAccountVariant1 | _ListCreativeFormatsRequestAccountVariant2 = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativeFormatsResponse(VersionedSchemaModel):
+    formats: builtins.list[_ExternalCoreFormat]
+    creative_agents: builtins.list[_ListCreativeFormatsResponseCreativeAgentsItem] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        formats: builtins.list[_ExternalCoreFormat],
+        creative_agents: builtins.list[_ListCreativeFormatsResponseCreativeAgentsItem] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativesRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    filters: _ExternalCoreCreativeFilters | None
+    sort: _ListCreativesRequestSort | None
+    pagination: _ExternalCorePaginationRequest | None
+    include_assignments: builtins.bool
+    include_snapshot: builtins.bool
+    include_items: builtins.bool
+    include_variables: builtins.bool
+    include_pricing: builtins.bool
+    account: _ListCreativesRequestAccountVariant1 | _ListCreativesRequestAccountVariant2 | None
+    fields: builtins.list[Literal['creative_id', 'name', 'format_id', 'status', 'created_date', 'updated_date', 'tags', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        filters: _ExternalCoreCreativeFilters = ...,
+        sort: _ListCreativesRequestSort = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        include_assignments: builtins.bool = ...,
+        include_snapshot: builtins.bool = ...,
+        include_items: builtins.bool = ...,
+        include_variables: builtins.bool = ...,
+        include_pricing: builtins.bool = ...,
+        account: _ListCreativesRequestAccountVariant1 | _ListCreativesRequestAccountVariant2 = ...,
+        fields: builtins.list[Literal['creative_id', 'name', 'format_id', 'status', 'created_date', 'updated_date', 'tags', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativesResponse(VersionedSchemaModel):
+    query_summary: _ListCreativesResponseQuerySummary
+    pagination: _ExternalCorePaginationResponse
+    creatives: builtins.list[_ListCreativesResponseCreativesItem]
+    format_summary: builtins.dict[builtins.str, Any] | None
+    status_summary: _ListCreativesResponseStatusSummary | None
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query_summary: _ListCreativesResponseQuerySummary,
+        pagination: _ExternalCorePaginationResponse,
+        creatives: builtins.list[_ListCreativesResponseCreativesItem],
+        format_summary: builtins.dict[builtins.str, Any] = ...,
+        status_summary: _ListCreativesResponseStatusSummary = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListPropertyListsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _ListPropertyListsRequestAccountVariant1 | _ListPropertyListsRequestAccountVariant2 | None
+    name_contains: builtins.str | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        account: _ListPropertyListsRequestAccountVariant1 | _ListPropertyListsRequestAccountVariant2 = ...,
+        name_contains: builtins.str = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListPropertyListsResponse(VersionedSchemaModel):
+    lists: builtins.list[_ExternalPropertyPropertyList]
+    pagination: _ExternalCorePaginationResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        lists: builtins.list[_ExternalPropertyPropertyList],
+        pagination: _ExternalCorePaginationResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class LogEventRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    event_source_id: builtins.str
+    test_event_code: builtins.str | None
+    events: builtins.list[_ExternalCoreEvent]
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        event_source_id: builtins.str,
+        events: builtins.list[_ExternalCoreEvent],
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        test_event_code: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class LogEventResponse(VersionedSchemaModel):
+    events_received: builtins.int | None
+    events_processed: builtins.int | None
+    partial_failures: builtins.list[_LogEventResponsePartialFailuresItem] | None
+    warnings: builtins.list[builtins.str] | None
+    match_quality: builtins.float | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        events_received: builtins.int,
+        events_processed: builtins.int,
+        partial_failures: builtins.list[_LogEventResponsePartialFailuresItem] = ...,
+        warnings: builtins.list[builtins.str] = ...,
+        match_quality: builtins.float = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PackageRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    product_id: builtins.str
+    format_ids: builtins.list[_ExternalCoreFormatId] | None
+    budget: builtins.float
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    pricing_option_id: builtins.str
+    bid_price: builtins.float | None
+    impressions: builtins.float | None
+    start_time: builtins.str | None
+    end_time: builtins.str | None
+    paused: builtins.bool
+    catalogs: builtins.list[_ExternalCoreCatalog] | None
+    optimization_goals: builtins.list[_PackageRequestOptimizationGoalsItemVariant1 | _PackageRequestOptimizationGoalsItemVariant2] | None
+    targeting_overlay: _ExternalCoreTargeting | None
+    measurement_terms: _ExternalCoreMeasurementTerms | None
+    performance_standards: builtins.list[_ExternalCorePerformanceStandard] | None
+    creative_assignments: builtins.list[_ExternalCoreCreativeAssignment] | None
+    creatives: builtins.list[_ExternalCoreCreativeAsset] | None
+    agency_estimate_number: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        product_id: builtins.str,
+        budget: builtins.float,
+        pricing_option_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bid_price: builtins.float = ...,
+        impressions: builtins.float = ...,
+        start_time: builtins.str = ...,
+        end_time: builtins.str = ...,
+        paused: builtins.bool = ...,
+        catalogs: builtins.list[_ExternalCoreCatalog] = ...,
+        optimization_goals: builtins.list[_PackageRequestOptimizationGoalsItemVariant1 | _PackageRequestOptimizationGoalsItemVariant2] = ...,
+        targeting_overlay: _ExternalCoreTargeting = ...,
+        measurement_terms: _ExternalCoreMeasurementTerms = ...,
+        performance_standards: builtins.list[_ExternalCorePerformanceStandard] = ...,
+        creative_assignments: builtins.list[_ExternalCoreCreativeAssignment] = ...,
+        creatives: builtins.list[_ExternalCoreCreativeAsset] = ...,
+        agency_estimate_number: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PreviewCreativeRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    request_type: Literal['single', 'batch', 'variant']
+    creative_manifest: _ExternalCoreCreativeManifest | None
+    format_id: _ExternalCoreFormatId | None
+    inputs: builtins.list[_PreviewCreativeRequestInputsItem] | None
+    template_id: builtins.str | None
+    quality: Literal['draft', 'production'] | None
+    output_format: Literal['url', 'html']
+    item_limit: builtins.int | None
+    requests: builtins.list[_PreviewCreativeRequestRequestsItem] | None
+    variant_id: builtins.str | None
+    creative_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        request_type: Literal['single', 'batch', 'variant'],
+        adcp_major_version: builtins.int = ...,
+        creative_manifest: _ExternalCoreCreativeManifest = ...,
+        format_id: _ExternalCoreFormatId = ...,
+        inputs: builtins.list[_PreviewCreativeRequestInputsItem] = ...,
+        template_id: builtins.str = ...,
+        quality: Literal['draft', 'production'] = ...,
+        output_format: Literal['url', 'html'] = ...,
+        item_limit: builtins.int = ...,
+        requests: builtins.list[_PreviewCreativeRequestRequestsItem] = ...,
+        variant_id: builtins.str = ...,
+        creative_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PreviewCreativeResponse(VersionedSchemaModel):
+    response_type: Literal['single'] | Literal['batch'] | Literal['variant']
+    previews: builtins.list[_PreviewCreativeResponsePreviewsItem] | builtins.list[_PreviewCreativeResponsePreviewsItem2] | None
+    interactive_url: builtins.str | None
+    expires_at: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_PreviewCreativeResponseResultsItemVariant1 | _PreviewCreativeResponseResultsItemVariant2] | None
+    variant_id: builtins.str | None
+    creative_id: builtins.str | None
+    manifest: _ExternalCoreCreativeManifest | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        response_type: Literal['single'],
+        previews: builtins.list[_PreviewCreativeResponsePreviewsItem],
+        expires_at: builtins.str,
+        interactive_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        response_type: Literal['batch'],
+        results: builtins.list[_PreviewCreativeResponseResultsItemVariant1 | _PreviewCreativeResponseResultsItemVariant2],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        response_type: Literal['variant'],
+        variant_id: builtins.str,
+        previews: builtins.list[_PreviewCreativeResponsePreviewsItem2],
+        creative_id: builtins.str = ...,
+        manifest: _ExternalCoreCreativeManifest = ...,
+        expires_at: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProvidePerformanceFeedbackRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    media_buy_id: builtins.str
+    idempotency_key: builtins.str
+    measurement_period: _ExternalCoreDatetimeRange
+    performance_index: builtins.float
+    package_id: builtins.str | None
+    creative_id: builtins.str | None
+    metric_type: Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency']
+    feedback_source: Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner']
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        idempotency_key: builtins.str,
+        measurement_period: _ExternalCoreDatetimeRange,
+        performance_index: builtins.float,
+        adcp_major_version: builtins.int = ...,
+        package_id: builtins.str = ...,
+        creative_id: builtins.str = ...,
+        metric_type: Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency'] = ...,
+        feedback_source: Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProvidePerformanceFeedbackResponse(VersionedSchemaModel):
+    success: Literal[True] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanOutcomeRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    plan_id: builtins.str
+    check_id: builtins.str | None
+    idempotency_key: builtins.str
+    purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']
+    outcome: Literal['completed', 'failed', 'delivery']
+    seller_response: _ReportPlanOutcomeRequestSellerResponse | None
+    delivery: _ReportPlanOutcomeRequestDelivery | None
+    error: _ReportPlanOutcomeRequestError | None
+    governance_context: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plan_id: builtins.str,
+        idempotency_key: builtins.str,
+        outcome: Literal['completed', 'failed', 'delivery'],
+        governance_context: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        check_id: builtins.str = ...,
+        purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services'] = ...,
+        seller_response: _ReportPlanOutcomeRequestSellerResponse = ...,
+        delivery: _ReportPlanOutcomeRequestDelivery = ...,
+        error: _ReportPlanOutcomeRequestError = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanOutcomeResponse(VersionedSchemaModel):
+    outcome_id: builtins.str
+    status: Literal['accepted', 'findings']
+    committed_budget: builtins.float | None
+    findings: builtins.list[_ReportPlanOutcomeResponseFindingsItem] | None
+    plan_summary: _ReportPlanOutcomeResponsePlanSummary | None
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        outcome_id: builtins.str,
+        status: Literal['accepted', 'findings'],
+        committed_budget: builtins.float = ...,
+        findings: builtins.list[_ReportPlanOutcomeResponseFindingsItem] = ...,
+        plan_summary: _ReportPlanOutcomeResponsePlanSummary = ...,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportUsageRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    reporting_period: _ExternalCoreDatetimeRange
+    usage: builtins.list[_ReportUsageRequestUsageItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        reporting_period: _ExternalCoreDatetimeRange,
+        usage: builtins.list[_ReportUsageRequestUsageItem],
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportUsageResponse(VersionedSchemaModel):
+    accepted: builtins.int
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        accepted: builtins.int,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiGetOfferingRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    offering_id: builtins.str
+    intent: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    include_products: builtins.bool
+    product_limit: builtins.int
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        offering_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        intent: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        include_products: builtins.bool = ...,
+        product_limit: builtins.int = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiGetOfferingResponse(VersionedSchemaModel):
+    available: builtins.bool
+    offering_token: builtins.str | None
+    ttl_seconds: builtins.int | None
+    checked_at: builtins.str | None
+    offering: _SiGetOfferingResponseOffering | None
+    matching_products: builtins.list[_SiGetOfferingResponseMatchingProductsItem] | None
+    total_matching: builtins.int | None
+    unavailable_reason: builtins.str | None
+    alternative_offering_ids: builtins.list[builtins.str] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        available: builtins.bool,
+        offering_token: builtins.str = ...,
+        ttl_seconds: builtins.int = ...,
+        checked_at: builtins.str = ...,
+        offering: _SiGetOfferingResponseOffering = ...,
+        matching_products: builtins.list[_SiGetOfferingResponseMatchingProductsItem] = ...,
+        total_matching: builtins.int = ...,
+        unavailable_reason: builtins.str = ...,
+        alternative_offering_ids: builtins.list[builtins.str] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiInitiateSessionRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    intent: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    identity: _ExternalSponsoredIntelligenceSiIdentity
+    media_buy_id: builtins.str | None
+    placement: builtins.str | None
+    offering_id: builtins.str | None
+    supported_capabilities: _ExternalSponsoredIntelligenceSiCapabilities | None
+    offering_token: builtins.str | None
+    idempotency_key: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        intent: builtins.str,
+        identity: _ExternalSponsoredIntelligenceSiIdentity,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        media_buy_id: builtins.str = ...,
+        placement: builtins.str = ...,
+        offering_id: builtins.str = ...,
+        supported_capabilities: _ExternalSponsoredIntelligenceSiCapabilities = ...,
+        offering_token: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiInitiateSessionResponse(VersionedSchemaModel):
+    session_id: builtins.str
+    response: _SiInitiateSessionResponseResponse | None
+    negotiated_capabilities: _ExternalSponsoredIntelligenceSiCapabilities | None
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated']
+    session_ttl_seconds: builtins.int | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        session_id: builtins.str,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'],
+        response: _SiInitiateSessionResponseResponse = ...,
+        negotiated_capabilities: _ExternalSponsoredIntelligenceSiCapabilities = ...,
+        session_ttl_seconds: builtins.int = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiSendMessageRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    session_id: builtins.str
+    message: builtins.str | None
+    action_response: _SiSendMessageRequestActionResponse | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        session_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        message: builtins.str = ...,
+        action_response: _SiSendMessageRequestActionResponse = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiSendMessageResponse(VersionedSchemaModel):
+    session_id: builtins.str
+    response: _SiSendMessageResponseResponse | None
+    mcp_resource_uri: builtins.str | None
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated']
+    handoff: _SiSendMessageResponseHandoff | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        session_id: builtins.str,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'],
+        response: _SiSendMessageResponseResponse = ...,
+        mcp_resource_uri: builtins.str = ...,
+        handoff: _SiSendMessageResponseHandoff = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiTerminateSessionRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    session_id: builtins.str
+    reason: Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated']
+    termination_context: _SiTerminateSessionRequestTerminationContext | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        session_id: builtins.str,
+        reason: Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated'],
+        adcp_major_version: builtins.int = ...,
+        termination_context: _SiTerminateSessionRequestTerminationContext = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiTerminateSessionResponse(VersionedSchemaModel):
+    session_id: builtins.str
+    terminated: builtins.bool
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'] | None
+    acp_handoff: _SiTerminateSessionResponseAcpHandoff | None
+    follow_up: _SiTerminateSessionResponseFollowUp | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        session_id: builtins.str,
+        terminated: builtins.bool,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'] = ...,
+        acp_handoff: _SiTerminateSessionResponseAcpHandoff = ...,
+        follow_up: _SiTerminateSessionResponseFollowUp = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAccountsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    accounts: builtins.list[_SyncAccountsRequestAccountsItem]
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        accounts: builtins.list[_SyncAccountsRequestAccountsItem],
+        adcp_major_version: builtins.int = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAccountsResponse(VersionedSchemaModel):
+    dry_run: builtins.bool | None
+    accounts: builtins.list[_SyncAccountsResponseAccountsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        accounts: builtins.list[_SyncAccountsResponseAccountsItem],
+        dry_run: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAudiencesRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncAudiencesRequestAccountVariant1 | _SyncAudiencesRequestAccountVariant2
+    audiences: builtins.list[_SyncAudiencesRequestAudiencesItem] | None
+    delete_missing: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncAudiencesRequestAccountVariant1 | _SyncAudiencesRequestAccountVariant2,
+        adcp_major_version: builtins.int = ...,
+        audiences: builtins.list[_SyncAudiencesRequestAudiencesItem] = ...,
+        delete_missing: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAudiencesResponse(VersionedSchemaModel):
+    audiences: builtins.list[_SyncAudiencesResponseAudiencesItem] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        audiences: builtins.list[_SyncAudiencesResponseAudiencesItem],
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncCatalogsRequestAccountVariant1 | _SyncCatalogsRequestAccountVariant2
+    catalogs: builtins.list[_ExternalCoreCatalog] | None
+    catalog_ids: builtins.list[builtins.str] | None
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    validation_mode: Literal['strict', 'lenient']
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncCatalogsRequestAccountVariant1 | _SyncCatalogsRequestAccountVariant2,
+        adcp_major_version: builtins.int = ...,
+        catalogs: builtins.list[_ExternalCoreCatalog] = ...,
+        catalog_ids: builtins.list[builtins.str] = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        validation_mode: Literal['strict', 'lenient'] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsSubmittedResponse(VersionedSchemaModel):
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsResponse(VersionedSchemaModel):
+    dry_run: builtins.bool | None
+    catalogs: builtins.list[_SyncCatalogsResponseCatalogsItem] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        catalogs: builtins.list[_SyncCatalogsResponseCatalogsItem],
+        dry_run: builtins.bool = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    catalogs_processed: builtins.int | None
+    catalogs_total: builtins.int | None
+    items_processed: builtins.int | None
+    items_total: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        catalogs_processed: builtins.int = ...,
+        catalogs_total: builtins.int = ...,
+        items_processed: builtins.int = ...,
+        items_total: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _SyncCreativesRequestAccountVariant1 | _SyncCreativesRequestAccountVariant2
+    creatives: builtins.list[_ExternalCoreCreativeAsset]
+    creative_ids: builtins.list[builtins.str] | None
+    assignments: builtins.list[_SyncCreativesRequestAssignmentsItem] | None
+    idempotency_key: builtins.str
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    validation_mode: Literal['strict', 'lenient']
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _SyncCreativesRequestAccountVariant1 | _SyncCreativesRequestAccountVariant2,
+        creatives: builtins.list[_ExternalCoreCreativeAsset],
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        creative_ids: builtins.list[builtins.str] = ...,
+        assignments: builtins.list[_SyncCreativesRequestAssignmentsItem] = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        validation_mode: Literal['strict', 'lenient'] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesSubmittedResponse(VersionedSchemaModel):
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesResponse(VersionedSchemaModel):
+    dry_run: builtins.bool | None
+    creatives: builtins.list[_SyncCreativesResponseCreativesItem] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    status: Literal['submitted'] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        creatives: builtins.list[_SyncCreativesResponseCreativesItem],
+        dry_run: builtins.bool = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    creatives_processed: builtins.int | None
+    creatives_total: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        creatives_processed: builtins.int = ...,
+        creatives_total: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncEventSourcesRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncEventSourcesRequestAccountVariant1 | _SyncEventSourcesRequestAccountVariant2
+    event_sources: builtins.list[_SyncEventSourcesRequestEventSourcesItem] | None
+    delete_missing: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncEventSourcesRequestAccountVariant1 | _SyncEventSourcesRequestAccountVariant2,
+        adcp_major_version: builtins.int = ...,
+        event_sources: builtins.list[_SyncEventSourcesRequestEventSourcesItem] = ...,
+        delete_missing: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncEventSourcesResponse(VersionedSchemaModel):
+    event_sources: builtins.list[_SyncEventSourcesResponseEventSourcesItem] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        event_sources: builtins.list[_SyncEventSourcesResponseEventSourcesItem],
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncGovernanceRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    accounts: builtins.list[_SyncGovernanceRequestAccountsItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        accounts: builtins.list[_SyncGovernanceRequestAccountsItem],
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncGovernanceResponse(VersionedSchemaModel):
+    accounts: builtins.list[_SyncGovernanceResponseAccountsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        accounts: builtins.list[_SyncGovernanceResponseAccountsItem],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncPlansRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    plans: builtins.list[_SyncPlansRequestPlansItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        plans: builtins.list[_SyncPlansRequestPlansItem],
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncPlansResponse(VersionedSchemaModel):
+    plans: builtins.list[_SyncPlansResponsePlansItem]
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plans: builtins.list[_SyncPlansResponsePlansItem],
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksGetRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    task_id: builtins.str
+    include_history: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        include_history: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksGetResponse(VersionedSchemaModel):
+    task_id: builtins.str
+    task_type: Literal['create_media_buy', 'update_media_buy', 'sync_creatives', 'activate_signal', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'get_rights', 'acquire_rights']
+    protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence']
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    created_at: builtins.str
+    updated_at: builtins.str
+    completed_at: builtins.str | None
+    has_webhook: builtins.bool | None
+    progress: _TasksGetResponseProgress | None
+    error: _TasksGetResponseError | None
+    history: builtins.list[_TasksGetResponseHistoryItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        task_type: Literal['create_media_buy', 'update_media_buy', 'sync_creatives', 'activate_signal', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'get_rights', 'acquire_rights'],
+        protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence'],
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        created_at: builtins.str,
+        updated_at: builtins.str,
+        completed_at: builtins.str = ...,
+        has_webhook: builtins.bool = ...,
+        progress: _TasksGetResponseProgress = ...,
+        error: _TasksGetResponseError = ...,
+        history: builtins.list[_TasksGetResponseHistoryItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    filters: _TasksListRequestFilters | None
+    sort: _TasksListRequestSort | None
+    pagination: _TasksListRequestPagination | None
+    include_history: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_major_version: builtins.int = ...,
+        filters: _TasksListRequestFilters = ...,
+        sort: _TasksListRequestSort = ...,
+        pagination: _TasksListRequestPagination = ...,
+        include_history: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksListResponse(VersionedSchemaModel):
+    query_summary: _TasksListResponseQuerySummary
+    tasks: builtins.list[_TasksListResponseTasksItem]
+    pagination: _TasksListResponsePagination
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query_summary: _TasksListResponseQuerySummary,
+        tasks: builtins.list[_TasksListResponseTasksItem],
+        pagination: _TasksListResponsePagination,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateCollectionListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _UpdateCollectionListRequestAccountVariant1 | _UpdateCollectionListRequestAccountVariant2 | None
+    name: builtins.str | None
+    description: builtins.str | None
+    base_collections: builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1 | _UpdateCollectionListRequestBaseCollectionsItemVariant2 | _UpdateCollectionListRequestBaseCollectionsItemVariant3] | None
+    filters: _ExternalCollectionCollectionListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    webhook_url: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdateCollectionListRequestAccountVariant1 | _UpdateCollectionListRequestAccountVariant2 = ...,
+        name: builtins.str = ...,
+        description: builtins.str = ...,
+        base_collections: builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1 | _UpdateCollectionListRequestBaseCollectionsItemVariant2 | _UpdateCollectionListRequestBaseCollectionsItemVariant3] = ...,
+        filters: _ExternalCollectionCollectionListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        webhook_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateCollectionListResponse(VersionedSchemaModel):
+    list: _ExternalCollectionCollectionList
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list: _ExternalCollectionCollectionList,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateContentStandardsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    scope: _UpdateContentStandardsRequestScope | None
+    registry_policy_ids: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _UpdateContentStandardsRequestCalibrationExemplars | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        scope: _UpdateContentStandardsRequestScope = ...,
+        registry_policy_ids: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _UpdateContentStandardsRequestCalibrationExemplars = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateContentStandardsResponse(VersionedSchemaModel):
+    success: Literal[True] | Literal[False]
+    standards_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    conflicting_standards_id: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[True],
+        standards_id: builtins.str,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        success: Literal[False],
+        errors: builtins.list[_ExternalCoreError],
+        conflicting_standards_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    account: _UpdateMediaBuyRequestAccountVariant1 | _UpdateMediaBuyRequestAccountVariant2
+    media_buy_id: builtins.str
+    revision: builtins.int | None
+    paused: builtins.bool | None
+    canceled: Literal[True] | None
+    cancellation_reason: builtins.str | None
+    start_time: Literal['asap'] | builtins.str | None
+    end_time: builtins.str | None
+    packages: builtins.list[_ExternalMediaBuyPackageUpdate] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    new_packages: builtins.list[_ExternalMediaBuyPackageRequest] | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _UpdateMediaBuyRequestAccountVariant1 | _UpdateMediaBuyRequestAccountVariant2,
+        media_buy_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        revision: builtins.int = ...,
+        paused: builtins.bool = ...,
+        canceled: Literal[True] = ...,
+        cancellation_reason: builtins.str = ...,
+        start_time: Literal['asap'] | builtins.str = ...,
+        end_time: builtins.str = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageUpdate] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        new_packages: builtins.list[_ExternalMediaBuyPackageRequest] = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuySubmittedResponse(VersionedSchemaModel):
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyResponse(VersionedSchemaModel):
+    media_buy_id: builtins.str | None
+    status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    revision: builtins.int | None
+    implementation_date: builtins.str | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    affected_packages: builtins.list[_ExternalCorePackage] | None
+    valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_packages', 'sync_creatives']] | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        revision: builtins.int = ...,
+        implementation_date: builtins.str | None = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        affected_packages: builtins.list[_ExternalCorePackage] = ...,
+        valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_packages', 'sync_creatives']] = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdatePropertyListRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _UpdatePropertyListRequestAccountVariant1 | _UpdatePropertyListRequestAccountVariant2 | None
+    name: builtins.str | None
+    description: builtins.str | None
+    base_properties: builtins.list[_UpdatePropertyListRequestBasePropertiesItemVariant1 | _UpdatePropertyListRequestBasePropertiesItemVariant2 | _UpdatePropertyListRequestBasePropertiesItemVariant3] | None
+    filters: _ExternalPropertyPropertyListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    webhook_url: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdatePropertyListRequestAccountVariant1 | _UpdatePropertyListRequestAccountVariant2 = ...,
+        name: builtins.str = ...,
+        description: builtins.str = ...,
+        base_properties: builtins.list[_UpdatePropertyListRequestBasePropertiesItemVariant1 | _UpdatePropertyListRequestBasePropertiesItemVariant2 | _UpdatePropertyListRequestBasePropertiesItemVariant3] = ...,
+        filters: _ExternalPropertyPropertyListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        webhook_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdatePropertyListResponse(VersionedSchemaModel):
+    list: _ExternalPropertyPropertyList
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list: _ExternalPropertyPropertyList,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateRightsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    end_date: builtins.str | None
+    impression_cap: builtins.int | None
+    pricing_option_id: builtins.str | None
+    paused: builtins.bool | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        end_date: builtins.str = ...,
+        impression_cap: builtins.int = ...,
+        pricing_option_id: builtins.str = ...,
+        paused: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateRightsResponse(VersionedSchemaModel):
+    rights_id: builtins.str | None
+    terms: _ExternalBrandRightsTerms | None
+    generation_credentials: builtins.list[_ExternalCoreGenerationCredential] | None
+    rights_constraint: _ExternalCoreRightsConstraint | None
+    paused: builtins.bool | None
+    implementation_date: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        terms: _ExternalBrandRightsTerms,
+        generation_credentials: builtins.list[_ExternalCoreGenerationCredential] = ...,
+        rights_constraint: _ExternalCoreRightsConstraint = ...,
+        paused: builtins.bool = ...,
+        implementation_date: builtins.str | None = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateContentDeliveryRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    records: builtins.list[_ValidateContentDeliveryRequestRecordsItem]
+    feature_ids: builtins.list[builtins.str] | None
+    include_passed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        records: builtins.list[_ValidateContentDeliveryRequestRecordsItem],
+        adcp_major_version: builtins.int = ...,
+        feature_ids: builtins.list[builtins.str] = ...,
+        include_passed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateContentDeliveryResponse(VersionedSchemaModel):
+    summary: _ValidateContentDeliveryResponseSummary | None
+    results: builtins.list[_ValidateContentDeliveryResponseResultsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        summary: _ValidateContentDeliveryResponseSummary,
+        results: builtins.list[_ValidateContentDeliveryResponseResultsItem],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidatePropertyDeliveryRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _ValidatePropertyDeliveryRequestAccountVariant1 | _ValidatePropertyDeliveryRequestAccountVariant2 | None
+    records: builtins.list[_ExternalPropertyDeliveryRecord]
+    include_compliant: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        records: builtins.list[_ExternalPropertyDeliveryRecord],
+        adcp_major_version: builtins.int = ...,
+        account: _ValidatePropertyDeliveryRequestAccountVariant1 | _ValidatePropertyDeliveryRequestAccountVariant2 = ...,
+        include_compliant: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidatePropertyDeliveryResponse(VersionedSchemaModel):
+    compliant: builtins.bool | None
+    list_id: builtins.str
+    summary: _ValidatePropertyDeliveryResponseSummary
+    aggregate: _ValidatePropertyDeliveryResponseAggregate | None
+    authorization_summary: _ValidatePropertyDeliveryResponseAuthorizationSummary | None
+    results: builtins.list[_ExternalPropertyValidationResult]
+    validated_at: builtins.str
+    list_resolved_at: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        summary: _ValidatePropertyDeliveryResponseSummary,
+        results: builtins.list[_ExternalPropertyValidationResult],
+        validated_at: builtins.str,
+        compliant: builtins.bool = ...,
+        aggregate: _ValidatePropertyDeliveryResponseAggregate = ...,
+        authorization_summary: _ValidatePropertyDeliveryResponseAuthorizationSummary = ...,
+        list_resolved_at: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+__all__ = ['AcquireRightsRequest', 'AcquireRightsResponse', 'ActivateSignalRequest', 'ActivateSignalResponse', 'BuildCreativeInputRequiredResponse', 'BuildCreativeRequest', 'BuildCreativeSubmittedResponse', 'BuildCreativeResponse', 'BuildCreativeWorkingResponse', 'CalibrateContentRequest', 'CalibrateContentResponse', 'CheckGovernanceRequest', 'CheckGovernanceResponse', 'ComplyTestControllerRequest', 'ComplyTestControllerResponse', 'ContextMatchRequest', 'ContextMatchResponse', 'CreateCollectionListRequest', 'CreateCollectionListResponse', 'CreateContentStandardsRequest', 'CreateContentStandardsResponse', 'CreateMediaBuyInputRequiredResponse', 'CreateMediaBuyRequest', 'CreateMediaBuySubmittedResponse', 'CreateMediaBuyResponse', 'CreateMediaBuyWorkingResponse', 'CreatePropertyListRequest', 'CreatePropertyListResponse', 'CreativeApprovalRequest', 'CreativeApprovalResponse', 'DeleteCollectionListRequest', 'DeleteCollectionListResponse', 'DeletePropertyListRequest', 'DeletePropertyListResponse', 'GetAccountFinancialsRequest', 'GetAccountFinancialsResponse', 'GetAdcpCapabilitiesRequest', 'GetAdcpCapabilitiesResponse', 'GetBrandIdentityRequest', 'GetBrandIdentityResponse', 'GetCollectionListRequest', 'GetCollectionListResponse', 'GetContentStandardsRequest', 'GetContentStandardsResponse', 'GetCreativeDeliveryRequest', 'GetCreativeDeliveryResponse', 'GetCreativeFeaturesRequest', 'GetCreativeFeaturesResponse', 'GetMediaBuyArtifactsRequest', 'GetMediaBuyArtifactsResponse', 'GetMediaBuyDeliveryRequest', 'GetMediaBuyDeliveryResponse', 'GetMediaBuysRequest', 'GetMediaBuysResponse', 'GetPlanAuditLogsRequest', 'GetPlanAuditLogsResponse', 'GetProductsInputRequiredResponse', 'GetProductsRequest', 'GetProductsSubmittedResponse', 'GetProductsResponse', 'GetProductsWorkingResponse', 'GetPropertyListRequest', 'GetPropertyListResponse', 'GetRightsRequest', 'GetRightsResponse', 'GetSignalsRequest', 'GetSignalsResponse', 'IdentityMatchRequest', 'IdentityMatchResponse', 'ListAccountsRequest', 'ListAccountsResponse', 'ListCollectionListsRequest', 'ListCollectionListsResponse', 'ListContentStandardsRequest', 'ListContentStandardsResponse', 'ListCreativeFormatsRequest', 'ListCreativeFormatsResponse', 'ListCreativesRequest', 'ListCreativesResponse', 'ListPropertyListsRequest', 'ListPropertyListsResponse', 'LogEventRequest', 'LogEventResponse', 'PackageRequest', 'PreviewCreativeRequest', 'PreviewCreativeResponse', 'ProvidePerformanceFeedbackRequest', 'ProvidePerformanceFeedbackResponse', 'ReportPlanOutcomeRequest', 'ReportPlanOutcomeResponse', 'ReportUsageRequest', 'ReportUsageResponse', 'SiGetOfferingRequest', 'SiGetOfferingResponse', 'SiInitiateSessionRequest', 'SiInitiateSessionResponse', 'SiSendMessageRequest', 'SiSendMessageResponse', 'SiTerminateSessionRequest', 'SiTerminateSessionResponse', 'SyncAccountsRequest', 'SyncAccountsResponse', 'SyncAudiencesRequest', 'SyncAudiencesResponse', 'SyncCatalogsInputRequiredResponse', 'SyncCatalogsRequest', 'SyncCatalogsSubmittedResponse', 'SyncCatalogsResponse', 'SyncCatalogsWorkingResponse', 'SyncCreativesInputRequiredResponse', 'SyncCreativesRequest', 'SyncCreativesSubmittedResponse', 'SyncCreativesResponse', 'SyncCreativesWorkingResponse', 'SyncEventSourcesRequest', 'SyncEventSourcesResponse', 'SyncGovernanceRequest', 'SyncGovernanceResponse', 'SyncPlansRequest', 'SyncPlansResponse', 'TasksGetRequest', 'TasksGetResponse', 'TasksListRequest', 'TasksListResponse', 'UpdateCollectionListRequest', 'UpdateCollectionListResponse', 'UpdateContentStandardsRequest', 'UpdateContentStandardsResponse', 'UpdateMediaBuyInputRequiredResponse', 'UpdateMediaBuyRequest', 'UpdateMediaBuySubmittedResponse', 'UpdateMediaBuyResponse', 'UpdateMediaBuyWorkingResponse', 'UpdatePropertyListRequest', 'UpdatePropertyListResponse', 'UpdateRightsRequest', 'UpdateRightsResponse', 'ValidateContentDeliveryRequest', 'ValidateContentDeliveryResponse', 'ValidatePropertyDeliveryRequest', 'ValidatePropertyDeliveryResponse']
diff --git a/src/adcp/types/v31.py b/src/adcp/types/v31.py
index e60e18ff7..f2c42b016 100644
--- a/src/adcp/types/v31.py
+++ b/src/adcp/types/v31.py
@@ -1,4 +1,4 @@
-"""Public AdCP 3.1 request/response models."""
+"""Public AdCP 3.1 boundary models with a generated static typing stub."""
 
 from adcp.types.versioned import versioned_surface
 
diff --git a/src/adcp/types/v31.pyi b/src/adcp/types/v31.pyi
new file mode 100644
index 000000000..0fab390b6
--- /dev/null
+++ b/src/adcp/types/v31.pyi
@@ -0,0 +1,41465 @@
+"""Generated typing surface for the dynamic version-scoped models."""
+
+from __future__ import annotations
+
+import builtins
+from typing import Any, Literal, overload
+from typing_extensions import Never, NotRequired, Required, TypedDict
+
+from adcp.types.versioned import VersionedSchemaModel
+
+# Underscored TypedDicts are private stub details used to type nested values.
+# Runtime composition remains dict-based through the public boundary models.
+
+class _ExternalCoreBrandRef(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_ExternalCoreBrandRefDataSubjectContestation]
+    brand_kit_override: NotRequired[_ExternalCoreBrandRefBrandKitOverride]
+
+class _AcquireRightsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _AcquireRightsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _AcquireRightsRequestCampaign(TypedDict, total=False):
+    description: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    estimated_impressions: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+
+class _ExternalCorePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_ExternalCorePushNotificationConfigAuthentication]
+
+class _ExternalCoreError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_ExternalCoreErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _ExternalBrandRightsTerms(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+    period: NotRequired[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual', 'one_time']]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    impression_cap: NotRequired[builtins.int]
+    overage_cpm: NotRequired[builtins.float]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    exclusivity: NotRequired[_ExternalBrandRightsTermsExclusivity]
+
+class _ExternalCoreGenerationCredential(TypedDict, total=False):
+    provider: Required[builtins.str]
+    rights_key: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    expires_at: NotRequired[builtins.str]
+    endpoint: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    text: NotRequired[builtins.str]
+
+class _ExternalCoreRightsConstraint(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_ExternalCoreRightsConstraintRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ActivateSignalRequestDestinationsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ActivateSignalRequestDestinationsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ActivateSignalRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ActivateSignalRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ActivateSignalResponseDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant1 | _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant1 | _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1 | _BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeRequestCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1 | _BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _BuildCreativeRequestMaxSpend(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant1 | _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant2 | _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant1 | _BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+    signal_agent_segment_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant2 | _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    signal_agent_segment_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant1 | _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant2 | _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant1 | _BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    signal_agent_segment_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestVariantAxis(TypedDict, total=False):
+    dimension: Required[Literal['voice', 'theme', 'best_of_n', 'transformer_config', 'custom']]
+    field: NotRequired[builtins.str]
+    values: NotRequired[builtins.list[Any]]
+    label: NotRequired[builtins.str]
+
+class _BuildCreativeRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _BuildCreativeRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _BuildCreativeRequestEvaluatorVariant1(TypedDict, total=False):
+    feature_requirement: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    rank_by: NotRequired[builtins.list[_BuildCreativeRequestEvaluatorVariant1RankByItem]]
+    feature_agent: NotRequired[_BuildCreativeRequestEvaluatorVariant1FeatureAgent]
+    eval_budget: NotRequired[_BuildCreativeRequestEvaluatorVariant1EvalBudget]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    exemplars: Required[_BuildCreativeRequestEvaluatorVariant1Exemplars]
+
+class _BuildCreativeRequestEvaluatorVariant2(TypedDict, total=False):
+    feature_requirement: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    rank_by: NotRequired[builtins.list[_BuildCreativeRequestEvaluatorVariant2RankByItem]]
+    feature_agent: NotRequired[_BuildCreativeRequestEvaluatorVariant2FeatureAgent]
+    eval_budget: NotRequired[_BuildCreativeRequestEvaluatorVariant2EvalBudget]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    evaluator_id: Required[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant3(TypedDict, total=False):
+    feature_requirement: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    rank_by: NotRequired[builtins.list[_BuildCreativeRequestEvaluatorVariant3RankByItem]]
+    feature_agent: NotRequired[_BuildCreativeRequestEvaluatorVariant3FeatureAgent]
+    eval_budget: NotRequired[_BuildCreativeRequestEvaluatorVariant3EvalBudget]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    agent_url: Required[builtins.str]
+
+class _BuildCreativeRequestPreviewInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponsePreview(TypedDict, total=False):
+    previews: Required[builtins.list[_BuildCreativeResponsePreviewPreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _ExternalCoreCreativeConsumption(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponsePreview2(TypedDict, total=False):
+    previews: Required[builtins.list[_BuildCreativeResponsePreview2PreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItem(TypedDict, total=False):
+    build_creative_id: NotRequired[builtins.str]
+    catalog_item_ref: NotRequired[_BuildCreativeResponseCreativesItemCatalogItemRef]
+    signal_condition: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant3]
+    variants: NotRequired[builtins.list[_BuildCreativeResponseCreativesItemVariantsItem]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _BuildCreativeResponseEstimate(TypedDict, total=False):
+    items_total: NotRequired[builtins.int]
+    items_to_produce: NotRequired[builtins.int]
+    conditions_total: NotRequired[builtins.int]
+    variants_per_item: NotRequired[builtins.int]
+    leaves_total: NotRequired[builtins.int]
+    currency: Required[builtins.str]
+    cost_low: Required[builtins.float]
+    cost_high: Required[builtins.float]
+    cost_expected: NotRequired[builtins.float]
+    basis: Required[Literal['fixed', 'estimated_units', 'cpm_deferred']]
+    per_leaf: NotRequired[builtins.list[_BuildCreativeResponseEstimatePerLeafItem]]
+
+class _ExternalContentStandardsArtifact(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_ExternalContentStandardsArtifactAssetsItemVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant3 | _ExternalContentStandardsArtifactAssetsItemVariant4]]
+    metadata: NotRequired[_ExternalContentStandardsArtifactMetadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_ExternalContentStandardsArtifactIdentifiers]
+
+class _CalibrateContentResponseFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalCorePlannedDelivery(TypedDict, total=False):
+    geo: NotRequired[_ExternalCorePlannedDeliveryGeo]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    frequency_cap: NotRequired[_ExternalCoreFrequencyCap]
+    audience_summary: NotRequired[builtins.str]
+    audience_targeting: NotRequired[builtins.list[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant4]]
+    total_budget: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestDeliveryMetrics(TypedDict, total=False):
+    reporting_period: Required[_CheckGovernanceRequestDeliveryMetricsReportingPeriod]
+    spend: NotRequired[builtins.float]
+    cumulative_spend: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.int]
+    cumulative_impressions: NotRequired[builtins.int]
+    geo_distribution: NotRequired[builtins.dict[builtins.str, builtins.float]]
+    channel_distribution: NotRequired[builtins.dict[builtins.str, builtins.float]]
+    pacing: NotRequired[Literal['ahead', 'on_track', 'behind']]
+    audience_distribution: NotRequired[_CheckGovernanceRequestDeliveryMetricsAudienceDistribution]
+
+class _ExternalCoreBusinessEntity(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_ExternalCoreBusinessEntityAddress]
+    contacts: NotRequired[builtins.list[_ExternalCoreBusinessEntityContactsItem]]
+    bank: NotRequired[_ExternalCoreBusinessEntityBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceResponseFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    policy_id: NotRequired[builtins.str]
+    source_plan_id: NotRequired[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    confidence: NotRequired[builtins.float]
+    uncertainty_reason: NotRequired[builtins.str]
+
+class _CheckGovernanceResponseConditionsItem(TypedDict, total=False):
+    field: Required[builtins.str]
+    required_value: NotRequired[Any]
+    reason: Required[builtins.str]
+
+class _ComplyTestControllerRequestParams(TypedDict, total=False):
+    creative_id: NotRequired[builtins.str]
+    account_id: NotRequired[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    session_id: NotRequired[builtins.str]
+    product_id: NotRequired[builtins.str]
+    pricing_option_id: NotRequired[builtins.str]
+    plan_id: NotRequired[builtins.str]
+    fixture: NotRequired[builtins.dict[builtins.str, Any]]
+    status: NotRequired[builtins.str]
+    rejection_reason: NotRequired[builtins.str]
+    purge_kind: NotRequired[Literal['soft', 'hard']]
+    reason_code: NotRequired[Literal['review_passed', 'review_failure', 'processing_failure', 'seller_rereview', 'policy_revocation', 'content_drift', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_deleted', 'takedown_request', 'advertiser_request', 'seller_archive', 'account_closed', 'account_suspended', 'retention_expired', 'legal_erasure']]
+    reason_detail: NotRequired[builtins.str]
+    termination_reason: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    clicks: NotRequired[builtins.int]
+    conversions: NotRequired[builtins.int]
+    reported_spend: NotRequired[_ComplyTestControllerRequestParamsReportedSpend]
+    reach: NotRequired[builtins.float]
+    frequency: NotRequired[builtins.float]
+    reach_window: NotRequired[_ComplyTestControllerRequestParamsReachWindow]
+    viewability: NotRequired[_ComplyTestControllerRequestParamsViewability]
+    spend_percentage: NotRequired[builtins.float]
+    arm: NotRequired[Literal['submitted', 'input-required']]
+    task_id: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+    format_id: NotRequired[builtins.str]
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    metrics: NotRequired[builtins.list[_ComplyTestControllerRequestParamsMetricsItem]]
+    tool: NotRequired[builtins.str]
+    upstream_name: NotRequired[builtins.str]
+    result: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerRequestAccount(TypedDict, total=False):
+    sandbox: Required[Literal[True]]
+
+class _ComplyTestControllerResponseForced(TypedDict, total=False):
+    arm: Required[Literal['submitted', 'input-required']]
+    task_id: NotRequired[builtins.str]
+
+class _ExternalCreativeAuditObservation(TypedDict, total=False):
+    code: Required[Literal['OVERSIGHT_DISCLOSURE_CARVEOUT_CLAIMED']]
+    severity: Required[Literal['audit-worthy']]
+    recovery: Required[Literal['informational']]
+    field: Required[builtins.str]
+    message: Required[builtins.str]
+    details: Required[_ExternalCreativeAuditObservationDetails]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant1(TypedDict, total=False):
+    method: Required[Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']]
+    endpoint: Required[builtins.str]
+    url: Required[builtins.str]
+    host: NotRequired[builtins.str]
+    path: NotRequired[builtins.str]
+    content_type: Required[builtins.str]
+    attestation_mode: Required[Literal['raw']]
+    purpose: NotRequired[Literal['platform_primary', 'measurement', 'attribution', 'creative_serving', 'identity', 'other']]
+    payload: Required[Any]
+    payload_digest_sha256: NotRequired[builtins.str]
+    payload_length: Required[builtins.int]
+    identifier_match_proofs: NotRequired[builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant1IdentifierMatchProofsItem]]
+    timestamp: Required[builtins.str]
+    status_code: NotRequired[builtins.int]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant2(TypedDict, total=False):
+    method: Required[Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']]
+    endpoint: Required[builtins.str]
+    url: Required[builtins.str]
+    host: NotRequired[builtins.str]
+    path: NotRequired[builtins.str]
+    content_type: Required[builtins.str]
+    attestation_mode: Required[Literal['digest']]
+    purpose: NotRequired[Literal['platform_primary', 'measurement', 'attribution', 'creative_serving', 'identity', 'other']]
+    payload: NotRequired[Any]
+    payload_digest_sha256: Required[builtins.str]
+    payload_length: Required[builtins.int]
+    identifier_match_proofs: NotRequired[builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant2IdentifierMatchProofsItem]]
+    timestamp: Required[builtins.str]
+    status_code: NotRequired[builtins.int]
+
+class _ContextMatchRequestArtifactRefsItem(TypedDict, total=False):
+    type: Required[Literal['url', 'url_hash', 'eidr', 'gracenote', 'isrc', 'gtin', 'rss_guid', 'isbn', 'custom']]
+    value: Required[builtins.str]
+
+class _ContextMatchRequestGeo(TypedDict, total=False):
+    country: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    metro: NotRequired[_ContextMatchRequestGeoMetro]
+
+class _ContextMatchRequestContextSignals(TypedDict, total=False):
+    topics: NotRequired[builtins.list[builtins.str]]
+    taxonomy_source: NotRequired[builtins.str]
+    taxonomy_id: NotRequired[builtins.int]
+    sentiment: NotRequired[Literal['positive', 'negative', 'neutral', 'mixed']]
+    keywords: NotRequired[builtins.list[builtins.str]]
+    language: NotRequired[builtins.str]
+    content_policies: NotRequired[builtins.list[builtins.str]]
+    summary: NotRequired[builtins.str]
+    embedding: NotRequired[builtins.str]
+    embedding_model: NotRequired[builtins.str]
+    embedding_dims: NotRequired[builtins.int]
+
+class _ExternalTrustedMatchOffer(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    seller_agent: NotRequired[_ExternalCoreSellerAgentRef]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    price: NotRequired[_ExternalTrustedMatchOfferPrice]
+    summary: NotRequired[builtins.str]
+    creative_manifest: NotRequired[_ExternalTrustedMatchOfferCreativeManifestVariant1 | _ExternalTrustedMatchOfferCreativeManifestVariant2]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+
+class _ContextMatchResponseSignals(TypedDict, total=False):
+    segments: NotRequired[builtins.list[builtins.str]]
+    targeting_kvs: NotRequired[builtins.list[_ContextMatchResponseSignalsTargetingKvsItem]]
+
+class _CreateCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreateCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _ExternalCollectionCollectionListFilters(TypedDict, total=False):
+    content_ratings_exclude: NotRequired[builtins.list[_ExternalCoreContentRating]]
+    content_ratings_include: NotRequired[builtins.list[_ExternalCoreContentRating]]
+    genres_exclude: NotRequired[builtins.list[builtins.str]]
+    genres_include: NotRequired[builtins.list[builtins.str]]
+    genre_taxonomy: NotRequired[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+    kinds: NotRequired[builtins.list[Literal['series', 'publication', 'event_series', 'rotation']]]
+    exclude_distribution_ids: NotRequired[builtins.list[_ExternalCollectionCollectionListFiltersExcludeDistributionIdsItem]]
+    production_quality: NotRequired[builtins.list[Literal['professional', 'prosumer', 'ugc']]]
+
+class _ExternalCollectionCollectionList(TypedDict, total=False):
+    list_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    account: NotRequired[_ExternalCollectionCollectionListAccountVariant1 | _ExternalCollectionCollectionListAccountVariant2]
+    base_collections: NotRequired[builtins.list[_ExternalCollectionCollectionListBaseCollectionsItemVariant1 | _ExternalCollectionCollectionListBaseCollectionsItemVariant2 | _ExternalCollectionCollectionListBaseCollectionsItemVariant3]]
+    filters: NotRequired[_ExternalCollectionCollectionListFilters]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    webhook_url: NotRequired[builtins.str]
+    cache_duration_hours: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    collection_count: NotRequired[builtins.int]
+
+class _CreateContentStandardsRequestScope(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: Required[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _ExternalGovernancePolicyEntry(TypedDict, total=False):
+    policy_id: Required[builtins.str]
+    source: NotRequired[Literal['registry', 'inline']]
+    version: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    category: NotRequired[Literal['regulation', 'standard']]
+    enforcement: Required[Literal['must', 'should', 'may']]
+    requires_human_review: NotRequired[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[builtins.str]]
+    region_aliases: NotRequired[builtins.dict[builtins.str, builtins.list[builtins.str]]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    governance_domains: NotRequired[builtins.list[Literal['campaign', 'property', 'creative', 'content_standards']]]
+    effective_date: NotRequired[builtins.str]
+    sunset_date: NotRequired[builtins.str]
+    source_url: NotRequired[builtins.str]
+    source_name: NotRequired[builtins.str]
+    policy: Required[builtins.str]
+    guidance: NotRequired[builtins.str]
+    exemplars: NotRequired[_ExternalGovernancePolicyEntryExemplars]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2]]
+
+class _CreateMediaBuyRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreateMediaBuyRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreateMediaBuyRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequest(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    product_id: Required[builtins.str]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_option_refs: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant1 | _ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    budget: Required[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: Required[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    committed_metrics: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1 | _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant2]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    creatives: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCreativesItemVariant1 | _ExternalMediaBuyPackageRequestCreativesItemVariant2]]
+    agency_estimate_number: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateMediaBuyRequestIoAcceptance(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    accepted_at: Required[builtins.str]
+    signatory: Required[builtins.str]
+    signature_id: NotRequired[builtins.str]
+
+class _ExternalCoreReportingWebhook(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: Required[_ExternalCoreReportingWebhookAuthentication]
+    reporting_frequency: Required[Literal['hourly', 'daily', 'monthly']]
+    requested_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+
+class _CreateMediaBuyRequestArtifactWebhook(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: Required[_CreateMediaBuyRequestArtifactWebhookAuthentication]
+    delivery_mode: Required[Literal['realtime', 'batched']]
+    batch_frequency: NotRequired[Literal['hourly', 'daily']]
+    sampling_rate: NotRequired[builtins.float]
+
+class _ExternalCoreAccount(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_ExternalCoreAccountCreditLimit]
+    setup: NotRequired[_ExternalCoreAccountSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_ExternalCoreAccountGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_ExternalCoreAccountReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_ExternalCoreNotificationConfig]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreMediaBuyAvailableAction(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ExternalCorePackage(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    impressions: NotRequired[builtins.float]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_option_refs: NotRequired[builtins.list[_ExternalCorePackageFormatOptionRefsItemVariant1 | _ExternalCorePackageFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    committed_metrics: NotRequired[builtins.list[_ExternalCorePackageCommittedMetricsItemVariant1 | _ExternalCorePackageCommittedMetricsItemVariant2]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    format_ids_to_provide: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    optimization_goals: NotRequired[builtins.list[_ExternalCorePackageOptimizationGoalsItemVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant2 | _ExternalCorePackageOptimizationGoalsItemVariant3]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_ExternalCorePackageCancellation]
+    agency_estimate_number: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreatePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreatePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyListFilters(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    property_types: NotRequired[builtins.list[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]]
+    feature_requirements: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    exclude_identifiers: NotRequired[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyList(TypedDict, total=False):
+    list_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    account: NotRequired[_ExternalPropertyPropertyListAccountVariant1 | _ExternalPropertyPropertyListAccountVariant2]
+    base_properties: NotRequired[builtins.list[_ExternalPropertyPropertyListBasePropertiesItemVariant1 | _ExternalPropertyPropertyListBasePropertiesItemVariant2 | _ExternalPropertyPropertyListBasePropertiesItemVariant3]]
+    filters: NotRequired[_ExternalPropertyPropertyListFilters]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    webhook_url: NotRequired[builtins.str]
+    cache_duration_hours: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    property_count: NotRequired[builtins.int]
+    pricing_options: NotRequired[builtins.list[_ExternalPropertyPropertyListPricingOptionsItemVariant1 | _ExternalPropertyPropertyListPricingOptionsItemVariant2 | _ExternalPropertyPropertyListPricingOptionsItemVariant3 | _ExternalPropertyPropertyListPricingOptionsItemVariant4 | _ExternalPropertyPropertyListPricingOptionsItemVariant5]]
+
+class _DeleteCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _DeleteCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _DeletePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _DeletePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAccountFinancialsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetAccountFinancialsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreDateRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _GetAccountFinancialsResponseAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetAccountFinancialsResponseAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAccountFinancialsResponseSpend(TypedDict, total=False):
+    total_spend: Required[builtins.float]
+    media_buy_count: NotRequired[builtins.int]
+
+class _GetAccountFinancialsResponseCredit(TypedDict, total=False):
+    credit_limit: Required[builtins.float]
+    available_credit: Required[builtins.float]
+    utilization_percent: NotRequired[builtins.float]
+
+class _GetAccountFinancialsResponseBalance(TypedDict, total=False):
+    available: Required[builtins.float]
+    last_top_up: NotRequired[_GetAccountFinancialsResponseBalanceLastTopUp]
+
+class _GetAccountFinancialsResponseInvoicesItem(TypedDict, total=False):
+    invoice_id: Required[builtins.str]
+    period: NotRequired[_ExternalCoreDateRange]
+    amount: Required[builtins.float]
+    status: Required[Literal['draft', 'issued', 'paid', 'past_due', 'void']]
+    due_date: NotRequired[builtins.str]
+    paid_date: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcp(TypedDict, total=False):
+    major_versions: Required[builtins.list[builtins.int]]
+    supported_versions: NotRequired[builtins.list[builtins.str]]
+    build_version: NotRequired[builtins.str]
+    idempotency: Required[_GetAdcpCapabilitiesResponseAdcpIdempotencyVariant1 | _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant2]
+
+class _GetAdcpCapabilitiesResponseAccount(TypedDict, total=False):
+    require_operator_auth: NotRequired[builtins.bool]
+    authorization_endpoint: NotRequired[builtins.str]
+    supported_billing: Required[builtins.list[Literal['operator', 'agent', 'advertiser']]]
+    required_for_products: NotRequired[builtins.bool]
+    account_financials: NotRequired[builtins.bool]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuy(TypedDict, total=False):
+    supported_pricing_models: NotRequired[builtins.list[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]]
+    buying_modes: NotRequired[builtins.list[Literal['brief', 'wholesale', 'refine']]]
+    reporting_delivery_methods: NotRequired[builtins.list[Literal['webhook', 'offline']]]
+    offline_delivery_protocols: NotRequired[builtins.list[Literal['s3', 'gcs', 'azure_blob']]]
+    supports_proposals: NotRequired[builtins.bool]
+    governance_aware: NotRequired[builtins.bool]
+    propagation_surfaces: NotRequired[builtins.list[Literal['snapshot', 'webhook', 'out_of_band']]]
+    creative_approval_mode: NotRequired[Literal['auto_approve', 'require_human']]
+    features: NotRequired[_ExternalCoreMediaBuyFeatures]
+    execution: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecution]
+    audience_targeting: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceTargeting]
+    supported_optimization_metrics: NotRequired[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    vendor_metric_optimization: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyVendorMetricOptimization]
+    conversion_tracking: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyConversionTracking]
+    frequency_capping: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyFrequencyCapping]
+    content_standards: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyContentStandards]
+    portfolio: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyPortfolio]
+
+class _GetAdcpCapabilitiesResponseSignals(TypedDict, total=False):
+    data_provider_domains: NotRequired[builtins.list[builtins.str]]
+    discovery_modes: NotRequired[builtins.list[Literal['brief', 'wholesale']]]
+    features: NotRequired[_GetAdcpCapabilitiesResponseSignalsFeatures]
+
+class _GetAdcpCapabilitiesResponseGovernance(TypedDict, total=False):
+    aggregation_window_days: NotRequired[builtins.int]
+    property_features: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItem]]
+    creative_features: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItem]]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligence(TypedDict, total=False):
+    endpoint: Required[_GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpoint]
+    capabilities: Required[_ExternalSponsoredIntelligenceSiCapabilities]
+    brand_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseBrand(TypedDict, total=False):
+    rights: NotRequired[builtins.bool]
+    right_types: NotRequired[builtins.list[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]]
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    generation_providers: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseCreative(TypedDict, total=False):
+    supports_compliance: NotRequired[builtins.bool]
+    has_creative_library: NotRequired[builtins.bool]
+    supports_generation: NotRequired[builtins.bool]
+    supports_transformation: NotRequired[builtins.bool]
+    supports_transformers: NotRequired[builtins.bool]
+    supports_refinement: NotRequired[builtins.bool]
+    supports_spend_controls: NotRequired[builtins.bool]
+    supports_evaluator: NotRequired[builtins.bool]
+    refinable_retention_seconds: NotRequired[builtins.int]
+    multiplicity: NotRequired[_GetAdcpCapabilitiesResponseCreativeMultiplicity]
+    supported_formats: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItem]]
+    bills_through_adcp: NotRequired[builtins.bool]
+    canonical_catalog_version: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseRequestSigning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    covers_content_digest: NotRequired[Literal['required', 'forbidden', 'either']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    warn_for: NotRequired[builtins.list[builtins.str]]
+    supported_for: NotRequired[builtins.list[builtins.str]]
+    protocol_methods_supported_for: NotRequired[builtins.list[builtins.str]]
+    protocol_methods_warn_for: NotRequired[builtins.list[builtins.str]]
+    protocol_methods_required_for: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseWebhookSigning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    profile: NotRequired[Literal['adcp/webhook-signing/v1']]
+    algorithms: NotRequired[builtins.list[Literal['ed25519', 'ecdsa-p256-sha256']]]
+    legacy_hmac_fallback: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseIdentity(TypedDict, total=False):
+    brand_json_url: NotRequired[builtins.str]
+    per_principal_key_isolation: NotRequired[builtins.bool]
+    key_origins: NotRequired[_GetAdcpCapabilitiesResponseIdentityKeyOrigins]
+    compromise_notification: NotRequired[_GetAdcpCapabilitiesResponseIdentityCompromiseNotification]
+
+class _GetAdcpCapabilitiesResponseMeasurement(TypedDict, total=False):
+    metrics: Required[builtins.list[_GetAdcpCapabilitiesResponseMeasurementMetricsItem]]
+
+class _GetAdcpCapabilitiesResponseComplianceTesting(TypedDict, total=False):
+    scenarios: Required[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseWholesaleFeedVersioning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    pricing_version_separate: NotRequired[builtins.bool]
+    cache_scope_account: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseWholesaleFeedWebhooks(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    event_types: NotRequired[builtins.list[Literal['product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+
+class _GetBrandIdentityResponseHouse(TypedDict, total=False):
+    domain: Required[builtins.str]
+    name: Required[builtins.str]
+
+class _GetBrandIdentityResponseLogosItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    orientation: NotRequired[Literal['square', 'horizontal', 'vertical', 'stacked']]
+    background: NotRequired[Literal['dark-bg', 'light-bg', 'transparent-bg']]
+    variant: NotRequired[Literal['primary', 'secondary', 'icon', 'wordmark', 'full-lockup']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    usage: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+
+class _GetBrandIdentityResponseColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str | builtins.list[builtins.str]]
+    secondary: NotRequired[builtins.str | builtins.list[builtins.str]]
+    accent: NotRequired[builtins.str | builtins.list[builtins.str]]
+    background: NotRequired[builtins.str | builtins.list[builtins.str]]
+    text: NotRequired[builtins.str | builtins.list[builtins.str]]
+
+class _GetBrandIdentityResponseFonts(TypedDict, total=False):
+    primary: NotRequired[builtins.str | _FontRoleVariant2]
+    secondary: NotRequired[builtins.str | _FontRoleVariant2]
+
+class _GetBrandIdentityResponseTone(TypedDict, total=False):
+    voice: NotRequired[builtins.str]
+    attributes: NotRequired[builtins.list[builtins.str]]
+    dos: NotRequired[builtins.list[builtins.str]]
+    donts: NotRequired[builtins.list[builtins.str]]
+
+class _GetBrandIdentityResponseVoiceSynthesis(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    voice_id: NotRequired[builtins.str]
+    settings: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetBrandIdentityResponseAssetsItem(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']]
+    url: Required[builtins.str]
+    tags: NotRequired[builtins.list[builtins.str]]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+    file_size_bytes: NotRequired[builtins.int]
+    format: NotRequired[builtins.str]
+
+class _GetBrandIdentityResponseRights(TypedDict, total=False):
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    exclusivity_model: NotRequired[builtins.str]
+    content_restrictions: NotRequired[builtins.list[builtins.str]]
+
+class _GetCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetCollectionListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetCollectionListResponseCollectionsItem(TypedDict, total=False):
+    collection_rid: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    distribution_ids: NotRequired[builtins.list[_GetCollectionListResponseCollectionsItemDistributionIdsItem]]
+    content_rating: NotRequired[_ExternalCoreContentRating]
+    genre: NotRequired[builtins.list[builtins.str]]
+    genre_taxonomy: NotRequired[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+    kind: NotRequired[Literal['series', 'publication', 'event_series', 'rotation']]
+
+class _ExternalCorePaginationResponse(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _GetCollectionListResponseCoverageGapsValueItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _GetContentStandardsResponseCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_GetContentStandardsResponsePricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCreativeDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCorePaginationRequest(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+    timezone: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    totals: NotRequired[_ExternalCoreDeliveryMetrics]
+    variant_count: NotRequired[builtins.int]
+    variants: Required[builtins.list[_ExternalCoreCreativeVariant]]
+
+class _GetCreativeDeliveryResponsePagination(TypedDict, total=False):
+    limit: Required[builtins.int]
+    offset: Required[builtins.int]
+    has_more: Required[builtins.bool]
+    total_count: NotRequired[builtins.int]
+    total: NotRequired[builtins.int]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeFeaturesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCreativeCreativeFeatureResult(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    value: Required[builtins.bool | builtins.float | builtins.str]
+    unit: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+    measured_at: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    methodology_version: NotRequired[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    policy_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuyArtifactsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuyArtifactsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuyArtifactsRequestTimeRange(TypedDict, total=False):
+    start: NotRequired[builtins.str]
+    end: NotRequired[builtins.str]
+
+class _GetMediaBuyArtifactsRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetMediaBuyArtifactsResponseArtifactsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    artifact: Required[_ExternalContentStandardsArtifact]
+    country: NotRequired[builtins.str]
+    channel: NotRequired[builtins.str]
+    brand_context: NotRequired[_GetMediaBuyArtifactsResponseArtifactsItemBrandContext]
+    local_verdict: NotRequired[Literal['pass', 'fail', 'unevaluated']]
+
+class _GetMediaBuyArtifactsResponseCollectionInfo(TypedDict, total=False):
+    total_deliveries: NotRequired[builtins.int]
+    total_collected: NotRequired[builtins.int]
+    returned_count: NotRequired[builtins.int]
+    effective_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuyDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuyDeliveryRequestAttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_GetMediaBuyDeliveryRequestAttributionWindowPostClick]
+    post_view: NotRequired[_GetMediaBuyDeliveryRequestAttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensions(TypedDict, total=False):
+    geo: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsGeo]
+    device_type: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDeviceType]
+    device_platform: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDevicePlatform]
+    audience: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsAudience]
+    placement: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsPlacement]
+
+class _GetMediaBuyDeliveryResponseReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalCoreAttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCoreAttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCoreAttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotals(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    media_buy_count: Required[builtins.int]
+    metric_aggregates: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1 | _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant2]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem(TypedDict, total=False):
+    media_buy_id: Required[builtins.str]
+    status: Required[Literal['pending_creatives', 'pending_start', 'pending', 'active', 'paused', 'completed', 'rejected', 'canceled', 'failed', 'reporting_delayed']]
+    expected_availability: NotRequired[builtins.str]
+    is_adjusted: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    pricing_model: NotRequired[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    totals: Required[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotals]
+    by_package: Required[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItem]]
+    windows: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItem]]
+    daily_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemDailyBreakdownItem]]
+
+class _GetMediaBuysRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuysRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItem(TypedDict, total=False):
+    media_buy_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    invoice_recipient: NotRequired[_ExternalCoreBusinessEntity]
+    status: Required[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]
+    status_as_of: NotRequired[builtins.str | None]
+    health: NotRequired[Literal['ok', 'impaired']]
+    impairments: NotRequired[builtins.list[_ExternalCoreImpairment]]
+    rejection_reason: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    total_budget: Required[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    confirmed_at: Required[builtins.str | None]
+    cancellation: NotRequired[_GetMediaBuysResponseMediaBuysItemCancellation]
+    revision: Required[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    valid_actions: NotRequired[builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]]
+    available_actions: NotRequired[builtins.list[_ExternalCoreMediaBuyAvailableAction]]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+    history: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemHistoryItem]]
+    packages: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    plan_version: Required[builtins.int]
+    status: Required[Literal['active', 'suspended', 'completed']]
+    budget: Required[_GetPlanAuditLogsResponsePlansItemBudget]
+    channel_allocation: NotRequired[builtins.dict[builtins.str, _GetPlanAuditLogsResponsePlansItemChannelAllocationValue]]
+    summary: Required[_GetPlanAuditLogsResponsePlansItemSummary]
+    entries: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItem]]
+    governed_actions: Required[builtins.list[_GetPlanAuditLogsResponsePlansItemGovernedActionsItem]]
+
+class _ExternalCoreProduct(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    publisher_properties: Required[builtins.list[_ExternalCoreProductPublisherPropertiesItemVariant1 | _ExternalCoreProductPublisherPropertiesItemVariant2 | _ExternalCoreProductPublisherPropertiesItemVariant3]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_options: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1 | _ExternalCoreProductFormatOptionsItemVariant2 | _ExternalCoreProductFormatOptionsItemVariant3 | _ExternalCoreProductFormatOptionsItemVariant4 | _ExternalCoreProductFormatOptionsItemVariant5 | _ExternalCoreProductFormatOptionsItemVariant6 | _ExternalCoreProductFormatOptionsItemVariant7 | _ExternalCoreProductFormatOptionsItemVariant8 | _ExternalCoreProductFormatOptionsItemVariant9 | _ExternalCoreProductFormatOptionsItemVariant10 | _ExternalCoreProductFormatOptionsItemVariant11 | _ExternalCoreProductFormatOptionsItemVariant12 | _ExternalCoreProductFormatOptionsItemVariant13]]
+    placements: NotRequired[builtins.list[_ExternalCorePlacement]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    delivery_type: Required[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    pricing_options: Required[builtins.list[_ExternalCoreProductPricingOptionsItemVariant1 | _ExternalCoreProductPricingOptionsItemVariant2 | _ExternalCoreProductPricingOptionsItemVariant3 | _ExternalCoreProductPricingOptionsItemVariant4 | _ExternalCoreProductPricingOptionsItemVariant5 | _ExternalCoreProductPricingOptionsItemVariant6 | _ExternalCoreProductPricingOptionsItemVariant7 | _ExternalCoreProductPricingOptionsItemVariant8 | _ExternalCoreProductPricingOptionsItemVariant9]]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    outcome_measurement: NotRequired[_ExternalCoreOutcomeMeasurement]
+    delivery_measurement: NotRequired[_ExternalCoreProductDeliveryMeasurement]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    cancellation_policy: NotRequired[_ExternalCoreCancellationPolicy]
+    allowed_actions: NotRequired[builtins.list[_ExternalCoreProductAllowedAction]]
+    reporting_capabilities: Required[_ExternalCoreReportingCapabilities]
+    creative_policy: NotRequired[_ExternalCoreCreativePolicy]
+    is_custom: NotRequired[builtins.bool]
+    property_targeting_allowed: NotRequired[builtins.bool]
+    data_provider_signals: NotRequired[builtins.list[_ExternalCoreProductDataProviderSignalsItemVariant1 | _ExternalCoreProductDataProviderSignalsItemVariant2 | _ExternalCoreProductDataProviderSignalsItemVariant3]]
+    included_signals: NotRequired[builtins.list[_ExternalCoreSignalListing]]
+    signal_targeting_options: NotRequired[builtins.list[_ExternalCoreProductSignalTargetingOption]]
+    signal_targeting_rules: NotRequired[_ExternalCoreSignalTargetingRules]
+    signal_targeting_allowed: NotRequired[builtins.bool]
+    catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    metric_optimization: NotRequired[_ExternalCoreProductMetricOptimization]
+    vendor_metric_optimization: NotRequired[_ExternalCoreVendorMetricOptimization]
+    max_optimization_goals: NotRequired[builtins.int]
+    measurement_readiness: NotRequired[_ExternalCoreMeasurementReadiness]
+    conversion_tracking: NotRequired[_ExternalCoreProductConversionTracking]
+    catalog_match: NotRequired[_ExternalCoreProductCatalogMatch]
+    brief_relevance: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    product_card: NotRequired[_ExternalCoreProductProductCard]
+    product_card_detailed: NotRequired[_ExternalCoreProductProductCardDetailed]
+    collections: NotRequired[builtins.list[_ExternalCoreCollectionSelector]]
+    collection_targeting_allowed: NotRequired[builtins.bool]
+    installments: NotRequired[builtins.list[_ExternalCoreInstallment]]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_ExternalCoreProductTrustedMatch]
+    material_submission: NotRequired[_ExternalCoreProductMaterialSubmission]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetProductsRequestRefineItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    ask: Required[builtins.str]
+
+class _GetProductsRequestRefineItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    action: NotRequired[Literal['include', 'omit', 'more_like_this']]
+    ask: NotRequired[builtins.str]
+
+class _GetProductsRequestRefineItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    action: NotRequired[Literal['include', 'omit', 'finalize']]
+    ask: NotRequired[builtins.str]
+
+class _ExternalCoreCatalog(TypedDict, total=False):
+    catalog_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    url: NotRequired[builtins.str]
+    feed_format: NotRequired[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'tiktok_shop', 'pinterest_catalog', 'openai_product_feed', 'custom']]
+    update_frequency: NotRequired[Literal['realtime', 'hourly', 'daily', 'weekly']]
+    items: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    ids: NotRequired[builtins.list[builtins.str]]
+    gtins: NotRequired[builtins.list[builtins.str]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    category: NotRequired[builtins.str]
+    query: NotRequired[builtins.str]
+    conversion_events: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+    feed_field_mappings: NotRequired[builtins.list[_ExternalCoreCatalogFieldMapping]]
+
+class _GetProductsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetProductsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFilters(TypedDict, total=False):
+    delivery_type: NotRequired[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    is_fixed_price: NotRequired[builtins.bool]
+    pricing_currencies: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    standard_formats_only: NotRequired[builtins.bool]
+    min_exposures: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    budget_range: NotRequired[_ExternalCoreProductFiltersBudgetRange]
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+    metros: NotRequired[builtins.list[_ExternalCoreProductFiltersMetrosItem]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    required_axe_integrations: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_ExternalCoreProductFiltersTrustedMatch]
+    required_features: NotRequired[_ExternalCoreMediaBuyFeatures]
+    required_geo_targeting: NotRequired[builtins.list[_ExternalCoreProductFiltersRequiredGeoTargetingItem]]
+    signal_targeting: NotRequired[builtins.list[_ExternalCoreProductFiltersSignalTargetingItemVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant3]]
+    postal_areas: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    geo_proximity: NotRequired[builtins.list[_ExternalCoreProductFiltersGeoProximityItemVariant1 | _ExternalCoreProductFiltersGeoProximityItemVariant2 | _ExternalCoreProductFiltersGeoProximityItemVariant3]]
+    required_performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    required_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    required_vendor_metrics: NotRequired[builtins.list[_ExternalCoreProductFiltersRequiredVendorMetricsItem]]
+    keywords: NotRequired[builtins.list[_ExternalCoreProductFiltersKeywordsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePropertyListRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _GetProductsRequestTimeBudget(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    allocations: Required[builtins.list[_ExternalCoreProductAllocation]]
+    proposal_status: NotRequired[Literal['draft', 'committed']]
+    expires_at: NotRequired[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+    total_budget_guidance: NotRequired[_ExternalCoreProposalTotalBudgetGuidance]
+    brief_alignment: NotRequired[builtins.str]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetProductsResponseRefinementAppliedItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseRefinementAppliedItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseRefinementAppliedItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseIncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['products', 'pricing', 'forecast', 'proposals', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_GetProductsResponseIncompleteItemEstimatedWait]
+
+class _GetProductsResponseFilterDiagnostics(TypedDict, total=False):
+    semantics: NotRequired[Literal['only', 'any', 'approximate']]
+    total_candidates: NotRequired[builtins.int]
+    excluded_by: NotRequired[builtins.dict[builtins.str, _GetProductsResponseFilterDiagnosticsExcludedByValue]]
+
+class _GetPropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetPropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetPropertyListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _ExternalCoreIdentifier(TypedDict, total=False):
+    type: Required[Literal['domain', 'subdomain', 'network_id', 'ios_bundle', 'android_package', 'apple_app_store_id', 'google_play_id', 'roku_store_id', 'fire_tv_asin', 'samsung_app_id', 'apple_tv_bundle', 'bundle_id', 'venue_id', 'screen_id', 'openooh_venue_type', 'rss_url', 'apple_podcast_id', 'spotify_collection_id', 'podcast_guid', 'station_id', 'facility_id']]
+    value: Required[builtins.str]
+
+class _GetRightsResponseRightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    brand_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    match_score: NotRequired[builtins.float]
+    match_reasons: NotRequired[builtins.list[builtins.str]]
+    available_uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    exclusivity_status: NotRequired[_GetRightsResponseRightsItemExclusivityStatus]
+    pricing_options: Required[builtins.list[_ExternalBrandRightsPricingOption]]
+    content_restrictions: NotRequired[builtins.list[builtins.str]]
+    preview_assets: NotRequired[builtins.list[_GetRightsResponseRightsItemPreviewAssetsItem]]
+
+class _GetRightsResponseExcludedItem(TypedDict, total=False):
+    brand_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    reason: Required[builtins.str]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetSignalsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetSignalsRequestSignalRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsRequestSignalRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsRequestSignalRefsItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsRequestSignalIdsItemVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsRequestSignalIdsItemVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsRequestDestinationsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _GetSignalsRequestDestinationsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ExternalCoreSignalFilters(TypedDict, total=False):
+    catalog_types: NotRequired[builtins.list[Literal['marketplace', 'custom', 'owned']]]
+    data_providers: NotRequired[builtins.list[builtins.str]]
+    max_cpm: NotRequired[builtins.float]
+    max_percent: NotRequired[builtins.float]
+    min_coverage_percentage: NotRequired[builtins.float]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItem(TypedDict, total=False):
+    signal_ref: NotRequired[_GetSignalsResponseSignalsItemSignalRefVariant1 | _GetSignalsResponseSignalsItemSignalRefVariant2 | _GetSignalsResponseSignalsItemSignalRefVariant3 | _GetSignalsResponseSignalsItemSignalRefVariant4 | _GetSignalsResponseSignalsItemSignalRefVariant5 | _GetSignalsResponseSignalsItemSignalRefVariant6 | _GetSignalsResponseSignalsItemSignalRefVariant7 | _GetSignalsResponseSignalsItemSignalRefVariant8 | _GetSignalsResponseSignalsItemSignalRefVariant9]
+    signal_id: NotRequired[_GetSignalsResponseSignalsItemSignalIdVariant1 | _GetSignalsResponseSignalsItemSignalIdVariant2]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_GetSignalsResponseSignalsItemRange]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    taxonomy: NotRequired[_GetSignalsResponseSignalsItemTaxonomy]
+    segmentation_criteria: NotRequired[builtins.str]
+    criteria_url: NotRequired[builtins.str]
+    data_sources: NotRequired[builtins.list[Literal['app_behavior', 'app_usage', 'web_usage', 'geo_location', 'email', 'tv_ott_or_stb_device', 'panel', 'online_ecommerce', 'credit_data', 'loyalty_card', 'transaction', 'online_survey', 'offline_survey', 'public_record_census', 'public_record_voter_file', 'public_record_other', 'offline_transaction']]]
+    methodology: NotRequired[Literal['observed', 'declared', 'derived', 'inferred', 'modeled']]
+    audience_expansion: NotRequired[builtins.bool]
+    device_expansion: NotRequired[builtins.bool]
+    refresh_cadence: NotRequired[Literal['intra_day', 'daily', 'weekly', 'monthly', 'bi_monthly', 'quarterly', 'bi_annually', 'annually']]
+    lookback_window: NotRequired[Literal['intra_day', 'daily', 'weekly', 'monthly', 'bi_monthly', 'quarterly', 'bi_annually', 'annually']]
+    onboarder: NotRequired[_GetSignalsResponseSignalsItemOnboarder]
+    countries: NotRequired[builtins.list[builtins.str]]
+    consent_basis: NotRequired[builtins.list[Literal['consent', 'legitimate_interest', 'contract', 'legal_obligation']]]
+    art9_basis: NotRequired[Literal['explicit_consent', 'manifestly_made_public', 'substantial_public_interest', 'vital_interests']]
+    modeling: NotRequired[_GetSignalsResponseSignalsItemModeling]
+    data_subject_rights: NotRequired[_GetSignalsResponseSignalsItemDataSubjectRights]
+    dts_compliant_version: NotRequired[builtins.str]
+    signal_agent_segment_id: Required[builtins.str]
+    signal_type: Required[Literal['marketplace', 'custom', 'owned']]
+    data_provider: NotRequired[builtins.str]
+    coverage_percentage: NotRequired[builtins.float]
+    coverage_forecast: NotRequired[_ExternalCoreSignalCoverageForecast]
+    deployments: Required[builtins.list[_GetSignalsResponseSignalsItemDeploymentsItemVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_GetSignalsResponseSignalsItemPricingOptionsItemVariant1 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant2 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant3 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant4 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant5]]
+
+class _GetSignalsResponseIncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['signals', 'pricing', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_GetSignalsResponseIncompleteItemEstimatedWait]
+
+class _GetTaskStatusRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetTaskStatusRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetTaskStatusResponseProgress(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+
+class _GetTaskStatusResponseError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    details: NotRequired[_GetTaskStatusResponseErrorDetails]
+
+class _GetTaskStatusResponseHistoryItem(TypedDict, total=False):
+    timestamp: Required[builtins.str]
+    type: Required[Literal['request', 'response']]
+    data: Required[builtins.dict[builtins.str, Any]]
+
+class _IdentityMatchRequestIdentitiesItem(TypedDict, total=False):
+    user_token: Required[builtins.str]
+    uid_type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]
+    attestation: NotRequired[_IdentityMatchRequestIdentitiesItemAttestation]
+
+class _IdentityMatchRequestConsent(TypedDict, total=False):
+    gdpr: NotRequired[builtins.bool]
+    tcf_consent: NotRequired[builtins.str]
+    gpp: NotRequired[builtins.str]
+    us_privacy: NotRequired[builtins.str]
+
+class _IdentityMatchRequestSealedCredentialsItem(TypedDict, total=False):
+    audience_kid: Required[builtins.str]
+    payload: Required[builtins.str]
+
+class _IdentityMatchResponseTmpxProvidersValue(TypedDict, total=False):
+    chunks: Required[builtins.list[_ExternalTrustedMatchTmpxChunk]]
+
+class _ListAccountsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListAccountsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreAccountWithAuthorization(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_ExternalCoreAccountWithAuthorizationCreditLimit]
+    setup: NotRequired[_ExternalCoreAccountWithAuthorizationSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_ExternalCoreAccountWithAuthorizationGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_ExternalCoreAccountWithAuthorizationReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_ExternalCoreNotificationConfig]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    authorization: NotRequired[_ExternalCoreAccountAuthorization]
+
+class _ListCollectionListsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCollectionListsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalContentStandardsContentStandards(TypedDict, total=False):
+    standards_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: NotRequired[builtins.list[builtins.str]]
+    policies: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+    calibration_exemplars: NotRequired[_ExternalContentStandardsContentStandardsCalibrationExemplars]
+    pricing_options: NotRequired[builtins.list[_ExternalContentStandardsContentStandardsPricingOptionsItemVariant1 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant2 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant3 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant4 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativeFormatsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCreativeFormatsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreFormat(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    example_url: NotRequired[builtins.str]
+    accepts_parameters: NotRequired[builtins.list[Literal['dimensions', 'duration']]]
+    renders: NotRequired[builtins.list[_ExternalCoreFormatRendersItemVariant1 | _ExternalCoreFormatRendersItemVariant2]]
+    assets: NotRequired[builtins.list[_ExternalCoreFormatAssetsItemVariant1 | _ExternalCoreFormatAssetsItemVariant2 | _ExternalCoreFormatAssetsItemVariant3 | _ExternalCoreFormatAssetsItemVariant4 | _ExternalCoreFormatAssetsItemVariant5 | _ExternalCoreFormatAssetsItemVariant6 | _ExternalCoreFormatAssetsItemVariant7 | _ExternalCoreFormatAssetsItemVariant8 | _ExternalCoreFormatAssetsItemVariant9 | _ExternalCoreFormatAssetsItemVariant10 | _ExternalCoreFormatAssetsItemVariant11 | _ExternalCoreFormatAssetsItemVariant12 | _ExternalCoreFormatAssetsItemVariant13 | _ExternalCoreFormatAssetsItemVariant14 | _ExternalCoreFormatAssetsItemVariant15 | _ExternalCoreFormatAssetsItemVariant16]]
+    delivery: NotRequired[builtins.dict[builtins.str, Any]]
+    supported_macros: NotRequired[builtins.list[Literal['MEDIA_BUY_ID', 'PACKAGE_ID', 'CREATIVE_ID', 'CACHEBUSTER', 'TIMESTAMP', 'CLICK_URL', 'GDPR', 'GDPR_CONSENT', 'US_PRIVACY', 'GPP_STRING', 'GPP_SID', 'IP_ADDRESS', 'LIMIT_AD_TRACKING', 'DEVICE_TYPE', 'OS', 'OS_VERSION', 'DEVICE_MAKE', 'DEVICE_MODEL', 'USER_AGENT', 'APP_BUNDLE', 'APP_NAME', 'COUNTRY', 'REGION', 'CITY', 'ZIP', 'DMA', 'LAT', 'LONG', 'DEVICE_ID', 'DEVICE_ID_TYPE', 'DOMAIN', 'PAGE_URL', 'REFERRER', 'KEYWORDS', 'PLACEMENT_ID', 'FOLD_POSITION', 'AD_WIDTH', 'AD_HEIGHT', 'VIDEO_ID', 'VIDEO_TITLE', 'VIDEO_DURATION', 'VIDEO_CATEGORY', 'CONTENT_GENRE', 'CONTENT_RATING', 'PLAYER_WIDTH', 'PLAYER_HEIGHT', 'POD_POSITION', 'POD_SIZE', 'AD_BREAK_ID', 'STATION_ID', 'COLLECTION_NAME', 'INSTALLMENT_ID', 'AUDIO_DURATION', 'TMPX', 'IMPRESSION_ID', 'AXEM', 'CATALOG_ID', 'SKU', 'GTIN', 'OFFERING_ID', 'JOB_ID', 'HOTEL_ID', 'FLIGHT_ID', 'VEHICLE_ID', 'LISTING_ID', 'STORE_ID', 'PROGRAM_ID', 'DESTINATION_ID', 'CREATIVE_VARIANT_ID', 'APP_ITEM_ID', 'ITEM_NAME', 'ITEM_DESCRIPTION', 'ITEM_TAGLINE', 'ITEM_PRICE', 'ITEM_PRICE_CURRENCY'] | builtins.str]]
+    input_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_card: NotRequired[_ExternalCoreFormatFormatCard]
+    accessibility: NotRequired[_ExternalCoreFormatAccessibility]
+    supported_disclosure_positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    disclosure_capabilities: NotRequired[builtins.list[_ExternalCoreFormatDisclosureCapabilitiesItem]]
+    format_card_detailed: NotRequired[_ExternalCoreFormatFormatCardDetailed]
+    reported_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreFormatPricingOptionsItemVariant1 | _ExternalCoreFormatPricingOptionsItemVariant2 | _ExternalCoreFormatPricingOptionsItemVariant3 | _ExternalCoreFormatPricingOptionsItemVariant4 | _ExternalCoreFormatPricingOptionsItemVariant5]]
+    canonical: NotRequired[_ExternalCoreCanonicalProjectionRef]
+    canonical_parameters: NotRequired[_ExternalCoreFormatCanonicalParametersVariant1 | _ExternalCoreFormatCanonicalParametersVariant2 | _ExternalCoreFormatCanonicalParametersVariant3 | _ExternalCoreFormatCanonicalParametersVariant4 | _ExternalCoreFormatCanonicalParametersVariant5 | _ExternalCoreFormatCanonicalParametersVariant6 | _ExternalCoreFormatCanonicalParametersVariant7 | _ExternalCoreFormatCanonicalParametersVariant8 | _ExternalCoreFormatCanonicalParametersVariant9 | _ExternalCoreFormatCanonicalParametersVariant10 | _ExternalCoreFormatCanonicalParametersVariant11 | _ExternalCoreFormatCanonicalParametersVariant12 | _ExternalCoreFormatCanonicalParametersVariant13]
+
+class _ListCreativeFormatsResponseCreativeAgentsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    agent_name: NotRequired[builtins.str]
+    capabilities: NotRequired[builtins.list[Literal['validation', 'assembly', 'generation', 'preview', 'delivery']]]
+
+class _ExternalCoreCreativeFilters(TypedDict, total=False):
+    accounts: NotRequired[builtins.list[_ExternalCoreCreativeFiltersAccountsItemVariant1 | _ExternalCoreCreativeFiltersAccountsItemVariant2]]
+    statuses: NotRequired[builtins.list[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    tags_any: NotRequired[builtins.list[builtins.str]]
+    name_contains: NotRequired[builtins.str]
+    creative_ids: NotRequired[builtins.list[builtins.str]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    assigned_to_packages: NotRequired[builtins.list[builtins.str]]
+    media_buy_ids: NotRequired[builtins.list[builtins.str]]
+    unassigned: NotRequired[builtins.bool]
+    has_served: NotRequired[builtins.bool]
+    concept_ids: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    has_variables: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_date', 'updated_date', 'name', 'status', 'assignment_count']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListCreativesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCreativesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListCreativesResponseQuerySummary(TypedDict, total=False):
+    total_matching: Required[builtins.int]
+    returned: Required[builtins.int]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_ListCreativesResponseQuerySummarySortApplied]
+
+class _ListCreativesResponseCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant1 | _ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant2]
+    status: Required[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    created_date: Required[builtins.str]
+    updated_date: Required[builtins.str]
+    assets: NotRequired[builtins.dict[builtins.str, Any]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    concept_id: NotRequired[builtins.str]
+    concept_name: NotRequired[builtins.str]
+    variables: NotRequired[builtins.list[_ExternalCoreCreativeVariable]]
+    assignments: NotRequired[_ListCreativesResponseCreativesItemVariant1Assignments]
+    snapshot: NotRequired[_ListCreativesResponseCreativesItemVariant1Snapshot]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    items: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant1ItemsItemVariant1 | _ListCreativesResponseCreativesItemVariant1ItemsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant1 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant2 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant3 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant4 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5]]
+    purge: NotRequired[_ListCreativesResponseCreativesItemVariant1Purge]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+
+class _ListCreativesResponseCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant1 | _ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant2]
+    status: Required[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    created_date: Required[builtins.str]
+    updated_date: Required[builtins.str]
+    assets: NotRequired[builtins.dict[builtins.str, Any]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    concept_id: NotRequired[builtins.str]
+    concept_name: NotRequired[builtins.str]
+    variables: NotRequired[builtins.list[_ExternalCoreCreativeVariable]]
+    assignments: NotRequired[_ListCreativesResponseCreativesItemVariant2Assignments]
+    snapshot: NotRequired[_ListCreativesResponseCreativesItemVariant2Snapshot]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    items: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant2ItemsItemVariant1 | _ListCreativesResponseCreativesItemVariant2ItemsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant1 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant2 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant3 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant4 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5]]
+    purge: NotRequired[_ListCreativesResponseCreativesItemVariant2Purge]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+
+class _ListCreativesResponseStatusSummary(TypedDict, total=False):
+    processing: NotRequired[builtins.int]
+    approved: NotRequired[builtins.int]
+    pending_review: NotRequired[builtins.int]
+    rejected: NotRequired[builtins.int]
+    archived: NotRequired[builtins.int]
+
+class _ListPropertyListsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListPropertyListsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListTasksRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListTasksRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListTasksRequestFilters(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    protocols: NotRequired[builtins.list[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]]
+    status: NotRequired[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    statuses: NotRequired[builtins.list[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]]
+    task_type: NotRequired[Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']]
+    task_types: NotRequired[builtins.list[Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    task_ids: NotRequired[builtins.list[builtins.str]]
+    context_contains: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _ListTasksRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_at', 'updated_at', 'status', 'task_type', 'protocol']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListTasksResponseQuerySummary(TypedDict, total=False):
+    total_matching: NotRequired[builtins.int]
+    returned: NotRequired[builtins.int]
+    domain_breakdown: NotRequired[_ListTasksResponseQuerySummaryDomainBreakdown]
+    status_breakdown: NotRequired[builtins.dict[builtins.str, builtins.int]]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_ListTasksResponseQuerySummarySortApplied]
+
+class _ListTasksResponseTasksItem(TypedDict, total=False):
+    task_id: Required[builtins.str]
+    task_type: Required[Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']]
+    domain: Required[Literal['media-buy', 'signals', 'creative']]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    created_at: Required[builtins.str]
+    updated_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _ListTransformersRequestExpandPaginationItem(TypedDict, total=False):
+    transformer_id: Required[builtins.str]
+    field: Required[builtins.str]
+    options_cursor: Required[builtins.str]
+
+class _ListTransformersRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListTransformersRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformer(TypedDict, total=False):
+    transformer_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    metadata: NotRequired[builtins.dict[builtins.str, Any]]
+    voice_synthesis_ref: NotRequired[builtins.list[_ExternalCoreTransformerVoiceSynthesisRefItem]]
+    input_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    output_format_ids: Required[builtins.list[_ExternalCoreFormatId]]
+    params: NotRequired[builtins.list[_ExternalCoreTransformerParam]]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreTransformerPricingOptionsItemVariant1 | _ExternalCoreTransformerPricingOptionsItemVariant2 | _ExternalCoreTransformerPricingOptionsItemVariant3 | _ExternalCoreTransformerPricingOptionsItemVariant4 | _ExternalCoreTransformerPricingOptionsItemVariant5]]
+    multiplicity: NotRequired[_ExternalCoreTransformerMultiplicity]
+
+class _ExternalCoreEvent(TypedDict, total=False):
+    event_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_time: Required[builtins.str]
+    user_match: NotRequired[_ExternalCoreUserMatch]
+    custom_data: NotRequired[_ExternalCoreEventCustomData]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    surface: NotRequired[_ExternalCoreEventSurface]
+    event_source_url: NotRequired[builtins.str]
+    custom_event_name: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _LogEventResponsePartialFailuresItem(TypedDict, total=False):
+    event_id: Required[builtins.str]
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+
+class _PackageRequestFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PackageRequestFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PackageRequestOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_PackageRequestOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant1TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _PackageRequestOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_PackageRequestOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant2TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant2TargetVariant2 | _PackageRequestOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _PackageRequestOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant3TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreTargeting(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.list[builtins.str]]
+    geo_countries_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_regions: NotRequired[builtins.list[builtins.str]]
+    geo_regions_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_metros: NotRequired[builtins.list[_ExternalCoreTargetingGeoMetrosItem]]
+    geo_metros_exclude: NotRequired[builtins.list[_ExternalCoreTargetingGeoMetrosExcludeItem]]
+    geo_postal_areas: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    geo_postal_areas_exclude: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    daypart_targets: NotRequired[builtins.list[_ExternalCoreDaypartTarget]]
+    axe_include_segment: NotRequired[builtins.str]
+    axe_exclude_segment: NotRequired[builtins.str]
+    audience_include: NotRequired[builtins.list[builtins.str]]
+    audience_exclude: NotRequired[builtins.list[builtins.str]]
+    signal_targeting_groups: NotRequired[_ExternalCorePackageSignalTargetingGroups]
+    signal_targeting: NotRequired[builtins.list[_ExternalCoreTargetingSignalTargetingItemVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant3]]
+    frequency_cap: NotRequired[_ExternalCoreFrequencyCap]
+    property_list: NotRequired[_ExternalCorePropertyListRef]
+    collection_list: NotRequired[_ExternalCoreCollectionListRef]
+    collection_list_exclude: NotRequired[_ExternalCoreCollectionListRef]
+    age_restriction: NotRequired[_ExternalCoreTargetingAgeRestriction]
+    device_platform: NotRequired[builtins.list[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]]
+    device_type: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    device_type_exclude: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    store_catchments: NotRequired[builtins.list[_ExternalCoreTargetingStoreCatchmentsItem]]
+    geo_proximity: NotRequired[builtins.list[_ExternalCoreTargetingGeoProximityItemVariant1 | _ExternalCoreTargetingGeoProximityItemVariant2 | _ExternalCoreTargetingGeoProximityItemVariant3]]
+    language: NotRequired[builtins.list[builtins.str]]
+    keyword_targets: NotRequired[builtins.list[_ExternalCoreTargetingKeywordTargetsItem]]
+    negative_keywords: NotRequired[builtins.list[_ExternalCoreTargetingNegativeKeywordsItem]]
+
+class _ExternalCoreMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_ExternalCoreMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_ExternalCoreMeasurementTermsMakegoodPolicy]
+
+class _ExternalCorePerformanceStandard(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_ExternalCoreBrandRef]
+
+class _PackageRequestCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_PackageRequestCommittedMetricsItemVariant1Qualifier]
+
+class _PackageRequestCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreCreativeAssignment(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _PackageRequestCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PackageRequestCreativesItemVariant1FormatOptionRefVariant1 | _PackageRequestCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_PackageRequestCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _PackageRequestCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PackageRequestCreativesItemVariant2FormatOptionRefVariant1 | _PackageRequestCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_PackageRequestCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _PreviewCreativeRequestCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1 | _PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1 | _PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeRequestRequestsItem(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    creative_manifest: Required[_PreviewCreativeRequestRequestsItemCreativeManifestVariant1 | _PreviewCreativeRequestRequestsItemCreativeManifestVariant2]
+    inputs: NotRequired[builtins.list[_PreviewCreativeRequestRequestsItemInputsItem]]
+    template_id: NotRequired[builtins.str]
+    quality: NotRequired[Literal['draft', 'production']]
+    output_format: NotRequired[Literal['url', 'html']]
+    item_limit: NotRequired[builtins.int]
+
+class _PreviewCreativeResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponsePreviewsItemInput]
+
+class _PreviewCreativeResponseResultsItemVariant1(TypedDict, total=False):
+    success: Required[Literal[True]]
+    creative_id: Required[builtins.str]
+    response: Required[_PreviewCreativeResponseResultsItemVariant1Response]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _PreviewCreativeResponseResultsItemVariant2(TypedDict, total=False):
+    success: Required[Literal[False]]
+    creative_id: Required[builtins.str]
+    response: NotRequired[_PreviewCreativeResponseResultsItemVariant2Response]
+    errors: Required[builtins.list[_ExternalCoreError]]
+
+class _PreviewCreativeResponsePreviewsItem2(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1 | _PreviewCreativeResponsePreviewsItem2RendersItemVariant2 | _PreviewCreativeResponsePreviewsItem2RendersItemVariant3]]
+
+class _PreviewCreativeResponseManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeResponseManifestVariant1FormatOptionRefVariant1 | _PreviewCreativeResponseManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeResponseManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeResponseManifestVariant2FormatOptionRefVariant1 | _PreviewCreativeResponseManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDatetimeRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalTrustedMatchTmpxChunk(TypedDict, total=False):
+    slot_id: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ReportPlanOutcomeRequestSellerResponse(TypedDict, total=False):
+    seller_reference: NotRequired[builtins.str]
+    committed_budget: NotRequired[builtins.float]
+    packages: NotRequired[builtins.list[_ReportPlanOutcomeRequestSellerResponsePackagesItem]]
+    planned_delivery: NotRequired[_ExternalCorePlannedDelivery]
+    creative_deadline: NotRequired[builtins.str]
+
+class _ReportPlanOutcomeRequestDelivery(TypedDict, total=False):
+    reporting_period: NotRequired[_ReportPlanOutcomeRequestDeliveryReportingPeriod]
+    impressions: NotRequired[builtins.int]
+    spend: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    viewability_rate: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float]
+
+class _ReportPlanOutcomeRequestError(TypedDict, total=False):
+    code: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+
+class _ReportPlanOutcomeResponseFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ReportPlanOutcomeResponsePlanSummary(TypedDict, total=False):
+    total_committed: NotRequired[builtins.float]
+    budget_remaining: NotRequired[builtins.float]
+
+class _ReportUsageRequestUsageItem(TypedDict, total=False):
+    account: Required[_ReportUsageRequestUsageItemAccountVariant1 | _ReportUsageRequestUsageItemAccountVariant2]
+    media_buy_id: NotRequired[builtins.str]
+    vendor_cost: Required[builtins.float]
+    currency: Required[builtins.str]
+    pricing_option_id: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    media_spend: NotRequired[builtins.float]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    standards_id: NotRequired[builtins.str]
+    rights_id: NotRequired[builtins.str]
+    creative_id: NotRequired[builtins.str]
+    build_variant_id: NotRequired[builtins.str]
+    property_list_id: NotRequired[builtins.str]
+    final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    measurement_window: NotRequired[builtins.str]
+
+class _SearchBrandResult(TypedDict, total=False):
+    brand_id: Required[builtins.str]
+    house: Required[_SearchBrandResultHouse]
+    names: Required[builtins.list[builtins.dict[builtins.str, builtins.str]]]
+    description: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']]]
+    keller_type: NotRequired[Literal['master', 'sub_brand', 'endorsed', 'independent']]
+    logos: NotRequired[builtins.list[_SearchBrandResultLogosItem]]
+    rights: NotRequired[_SearchBrandResultRights]
+
+class _SiGetOfferingResponseOffering(TypedDict, total=False):
+    offering_id: NotRequired[builtins.str]
+    title: NotRequired[builtins.str]
+    summary: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    availability_status: NotRequired[Literal['available', 'limited', 'sold_out', 'expired', 'region_restricted', 'inactive']]
+    price_hint: NotRequired[builtins.str]
+    image_url: NotRequired[builtins.str]
+    landing_url: NotRequired[builtins.str]
+
+class _SiGetOfferingResponseMatchingProductsItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    price: NotRequired[builtins.str]
+    original_price: NotRequired[builtins.str]
+    image_url: NotRequired[builtins.str]
+    availability_summary: NotRequired[builtins.str]
+    availability_status: NotRequired[Literal['available', 'limited', 'sold_out', 'expired', 'region_restricted', 'inactive']]
+    url: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContext(TypedDict, total=False):
+    paying_principal: Required[_ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipal]
+    context_use: Required[Literal['presentation_only', 'comparison_set', 'reasoning_context']]
+    disclosure_obligation: Required[_ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligation]
+    declared_at: NotRequired[builtins.str]
+    declared_by: NotRequired[_ExternalSponsoredIntelligenceSiSponsoredContextDeclaredBy]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalSponsoredIntelligenceSiIdentity(TypedDict, total=False):
+    consent_granted: Required[builtins.bool]
+    consent_timestamp: NotRequired[builtins.str]
+    consent_scope: NotRequired[builtins.list[Literal['name', 'email', 'shipping_address', 'phone', 'locale']]]
+    privacy_policy_acknowledged: NotRequired[_ExternalSponsoredIntelligenceSiIdentityPrivacyPolicyAcknowledged]
+    user: NotRequired[_ExternalSponsoredIntelligenceSiIdentityUser]
+    anonymous_session_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilities(TypedDict, total=False):
+    modalities: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesModalities]
+    components: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesComponents]
+    commerce: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesCommerce]
+    a2ui: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesA2ui]
+    mcp_apps: NotRequired[builtins.bool]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextReceipt(TypedDict, total=False):
+    sponsored_context: Required[_ExternalSponsoredIntelligenceSiSponsoredContext]
+    host_receipt: Required[_ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceipt]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiInitiateSessionResponseResponse(TypedDict, total=False):
+    message: NotRequired[builtins.str]
+    ui_elements: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiUiElement]]
+
+class _SiSendMessageRequestActionResponse(TypedDict, total=False):
+    action: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiSendMessageResponseResponse(TypedDict, total=False):
+    message: NotRequired[builtins.str]
+    surface: NotRequired[_ExternalA2uiSurface]
+    ui_elements: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiUiElement]]
+
+class _SiSendMessageResponseHandoff(TypedDict, total=False):
+    type: NotRequired[Literal['transaction', 'complete']]
+    intent: NotRequired[_SiSendMessageResponseHandoffIntent]
+    context_for_checkout: NotRequired[_SiSendMessageResponseHandoffContextForCheckout]
+
+class _SiTerminateSessionRequestTerminationContext(TypedDict, total=False):
+    summary: NotRequired[builtins.str]
+    transaction_intent: NotRequired[_SiTerminateSessionRequestTerminationContextTransactionIntent]
+    cause: NotRequired[builtins.str]
+
+class _SiTerminateSessionResponseAcpHandoff(TypedDict, total=False):
+    checkout_url: NotRequired[builtins.str]
+    checkout_token: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    expires_at: NotRequired[builtins.str]
+
+class _SiTerminateSessionResponseFollowUp(TypedDict, total=False):
+    action: NotRequired[Literal['save_for_later', 'set_reminder', 'subscribe_updates', 'none']]
+    data: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _StaleResponseUpstream(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+
+class _StaleResponseOriginalError(TypedDict, total=False):
+    code: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant1(TypedDict, total=False):
+    account: NotRequired[_SyncAccountsRequestAccountsItemVariant1AccountVariant1 | _SyncAccountsRequestAccountsItemVariant1AccountVariant2]
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    billing: Required[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    sandbox: NotRequired[builtins.bool]
+    preferred_reporting_protocol: NotRequired[Literal['s3', 'gcs', 'azure_blob']]
+    notification_configs: NotRequired[builtins.list[_SyncAccountsRequestAccountsItemVariant1NotificationConfigsItem]]
+
+class _SyncAccountsRequestAccountsItemVariant2(TypedDict, total=False):
+    account: Required[_SyncAccountsRequestAccountsItemVariant2AccountVariant1 | _SyncAccountsRequestAccountsItemVariant2AccountVariant2]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    sandbox: NotRequired[builtins.bool]
+    preferred_reporting_protocol: NotRequired[Literal['s3', 'gcs', 'azure_blob']]
+    notification_configs: NotRequired[builtins.list[_SyncAccountsRequestAccountsItemVariant2NotificationConfigsItem]]
+
+class _SyncAccountsResponseAccountsItem(TypedDict, total=False):
+    account_id: NotRequired[builtins.str]
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed']]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    setup: NotRequired[_SyncAccountsResponseAccountsItemSetup]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_SyncAccountsResponseAccountsItemCreditLimit]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_ExternalCoreNotificationConfig]]
+    authorization: NotRequired[_ExternalCoreAccountAuthorization]
+
+class _SyncAudiencesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAudiencesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAudiencesRequestAudiencesItem(TypedDict, total=False):
+    audience_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    audience_type: NotRequired[Literal['crm', 'suppression', 'lookalike_seed']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    add: NotRequired[builtins.list[_ExternalCoreAudienceMember]]
+    remove: NotRequired[builtins.list[_ExternalCoreAudienceMember]]
+    delete: NotRequired[builtins.bool]
+    consent_basis: NotRequired[Literal['consent', 'legitimate_interest', 'contract', 'legal_obligation']]
+
+class _SyncAudiencesResponseAudiencesItem(TypedDict, total=False):
+    audience_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    seller_id: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'deleted', 'failed']]
+    status: NotRequired[Literal['processing', 'ready', 'too_small', 'suspended']]
+    uploaded_count: NotRequired[builtins.int]
+    total_uploaded_count: NotRequired[builtins.int]
+    matched_count: NotRequired[builtins.int]
+    effective_match_rate: NotRequired[builtins.float]
+    match_breakdown: NotRequired[builtins.list[_SyncAudiencesResponseAudiencesItemMatchBreakdownItem]]
+    last_synced_at: NotRequired[builtins.str]
+    minimum_size: NotRequired[builtins.int]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncCatalogsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncCatalogsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncCatalogsResponseCatalogsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    platform_id: NotRequired[builtins.str]
+    item_count: NotRequired[builtins.int]
+    items_approved: NotRequired[builtins.int]
+    items_pending: NotRequired[builtins.int]
+    items_rejected: NotRequired[builtins.int]
+    item_issues: NotRequired[builtins.list[_SyncCatalogsResponseCatalogsItemItemIssuesItem]]
+    last_synced_at: NotRequired[builtins.str]
+    next_fetch_at: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncCreativesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncCreativesRequestCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant1 | _SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_SyncCreativesRequestCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _SyncCreativesRequestCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant1 | _SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_SyncCreativesRequestCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _SyncCreativesRequestAssignmentsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    platform_id: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    preview_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    assigned_to: NotRequired[builtins.list[builtins.str]]
+    assignment_errors: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncEventSourcesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncEventSourcesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncEventSourcesRequestEventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    allowed_domains: NotRequired[builtins.list[builtins.str]]
+    surface: NotRequired[_ExternalCoreEventSurface]
+
+class _SyncEventSourcesResponseEventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    seller_id: NotRequired[builtins.str]
+    event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    surface: NotRequired[_ExternalCoreEventSurface]
+    managed_by: NotRequired[Literal['buyer', 'seller']]
+    setup: NotRequired[_SyncEventSourcesResponseEventSourcesItemSetup]
+    action: Required[Literal['created', 'updated', 'unchanged', 'deleted', 'failed']]
+    health: NotRequired[_ExternalCoreEventSourceHealth]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncGovernanceRequestAccountsItem(TypedDict, total=False):
+    account: Required[_SyncGovernanceRequestAccountsItemAccountVariant1 | _SyncGovernanceRequestAccountsItemAccountVariant2]
+    governance_agents: Required[builtins.list[_SyncGovernanceRequestAccountsItemGovernanceAgentsItem]]
+
+class _SyncGovernanceResponseAccountsItem(TypedDict, total=False):
+    account: Required[_SyncGovernanceResponseAccountsItemAccountVariant1 | _SyncGovernanceResponseAccountsItemAccountVariant2]
+    status: Required[Literal['synced', 'failed']]
+    governance_agents: NotRequired[builtins.list[_SyncGovernanceResponseAccountsItemGovernanceAgentsItem]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncPlansRequestPlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    brand: Required[_ExternalCoreBrandRef]
+    objectives: Required[builtins.str]
+    budget: Required[_SyncPlansRequestPlansItemBudgetVariant1 | _SyncPlansRequestPlansItemBudgetVariant2]
+    channels: NotRequired[_SyncPlansRequestPlansItemChannels]
+    flight: Required[_SyncPlansRequestPlansItemFlight]
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+    policy_ids: NotRequired[builtins.list[builtins.str]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    audience: NotRequired[_ExternalGovernanceAudienceConstraints]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    restricted_attributes_custom: NotRequired[builtins.list[builtins.str]]
+    min_audience_size: NotRequired[builtins.int]
+    human_review_required: NotRequired[builtins.bool]
+    custom_policies: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+    approved_sellers: NotRequired[builtins.list[builtins.str] | None]
+    delegations: NotRequired[builtins.list[_SyncPlansRequestPlansItemDelegationsItem]]
+    portfolio: NotRequired[_SyncPlansRequestPlansItemPortfolio]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncPlansResponsePlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    status: Required[Literal['active', 'error']]
+    version: Required[builtins.int]
+    categories: NotRequired[builtins.list[_SyncPlansResponsePlansItemCategoriesItem]]
+    resolved_policies: NotRequired[builtins.list[_SyncPlansResponsePlansItemResolvedPoliciesItem]]
+
+class _TasksGetRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_TasksGetRequestAccountVariant2Brand]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _TasksGetResponseAdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseAdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponsePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponsePushNotificationConfigAuthentication]
+
+class _TasksGetResponseProgress(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+
+class _TasksGetResponseError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    details: NotRequired[_TasksGetResponseErrorDetails]
+
+class _TasksGetResponseHistoryItem(TypedDict, total=False):
+    timestamp: Required[builtins.str]
+    type: Required[Literal['request', 'response']]
+    data: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant1AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant1PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    products: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItem]]
+    extensions: NotRequired[builtins.dict[builtins.str, Any]]
+    proposals: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItem]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant1ErrorsItem]]
+    property_list_applied: NotRequired[builtins.bool]
+    catalog_applied: NotRequired[builtins.bool]
+    refinement_applied: NotRequired[builtins.list[_TasksGetResponseResultVariant1RefinementAppliedItemVariant1 | _TasksGetResponseResultVariant1RefinementAppliedItemVariant2 | _TasksGetResponseResultVariant1RefinementAppliedItemVariant3]]
+    incomplete: NotRequired[builtins.list[_TasksGetResponseResultVariant1IncompleteItem]]
+    filter_diagnostics: NotRequired[_TasksGetResponseResultVariant1FilterDiagnostics]
+    pagination: NotRequired[_TasksGetResponseResultVariant1Pagination]
+    wholesale_feed_version: NotRequired[builtins.str]
+    pricing_version: NotRequired[builtins.str]
+    cache_scope: NotRequired[Literal['public', 'account']]
+    unchanged: NotRequired[Literal[True]]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant2(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3(TypedDict, total=False):
+    reason: NotRequired[Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED']]
+    partial_results: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItem]]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant4(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    estimated_completion: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant4ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant5AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant5PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    signals: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItem]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant5ErrorsItem]]
+    incomplete: NotRequired[builtins.list[_TasksGetResponseResultVariant5IncompleteItem]]
+    wholesale_feed_version: NotRequired[builtins.str]
+    pricing_version: NotRequired[builtins.str]
+    cache_scope: NotRequired[Literal['public', 'account']]
+    unchanged: NotRequired[Literal[True]]
+    pagination: NotRequired[_TasksGetResponseResultVariant5Pagination]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant6(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant7(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    estimated_completion: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant7ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['completed', 'canceled', 'rejected']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant8Variant1AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant8Variant1PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    media_buy_id: Required[builtins.str]
+    account: NotRequired[_TasksGetResponseResultVariant8Variant1Account]
+    invoice_recipient: NotRequired[_TasksGetResponseResultVariant8Variant1InvoiceRecipient]
+    media_buy_status: NotRequired[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]
+    confirmed_at: Required[builtins.str | None]
+    creative_deadline: NotRequired[builtins.str]
+    revision: Required[builtins.int]
+    currency: NotRequired[builtins.str]
+    total_budget: NotRequired[builtins.float]
+    valid_actions: NotRequired[builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]]
+    available_actions: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AvailableActionsItem]]
+    packages: Required[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItem]]
+    planned_delivery: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDelivery]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant2(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant8Variant2AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant8Variant2PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: Required[builtins.list[_TasksGetResponseResultVariant8Variant2ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant3(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: Required[builtins.str]
+    status: Required[Literal['submitted']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant8Variant3AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant8Variant3PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant3ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant9(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant10(TypedDict, total=False):
+    reason: NotRequired[Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT']]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant10ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant11(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant11ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['completed', 'canceled', 'rejected']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant12Variant1AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant12Variant1PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    media_buy_id: Required[builtins.str]
+    media_buy_status: NotRequired[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]
+    revision: Required[builtins.int]
+    currency: NotRequired[builtins.str]
+    total_budget: NotRequired[builtins.float]
+    implementation_date: NotRequired[builtins.str | None]
+    invoice_recipient: NotRequired[_TasksGetResponseResultVariant12Variant1InvoiceRecipient]
+    affected_packages: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItem]]
+    valid_actions: NotRequired[builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]]
+    available_actions: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AvailableActionsItem]]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant2(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant12Variant2AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant12Variant2PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: Required[builtins.list[_TasksGetResponseResultVariant12Variant2ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant3(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: Required[builtins.str]
+    status: Required[Literal['submitted']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant12Variant3AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant12Variant3PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant3ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant13(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant14(TypedDict, total=False):
+    reason: NotRequired[Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION']]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant15(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant15ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16(TypedDict, total=False):
+    notification_type: Required[Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update']]
+    partial_data: NotRequired[builtins.bool]
+    unavailable_count: NotRequired[builtins.int]
+    sequence_number: NotRequired[builtins.int]
+    next_expected_at: NotRequired[builtins.str]
+    reporting_period: Required[_TasksGetResponseResultVariant16ReportingPeriod]
+    currency: Required[builtins.str]
+    attribution_window: NotRequired[_TasksGetResponseResultVariant16AttributionWindow]
+    media_buy_deliveries: Required[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItem]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant16ErrorsItem]]
+    sandbox: NotRequired[builtins.bool]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant17Variant1AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant17Variant1PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    creative_manifest: Required[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1 | _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2]
+    build_variant_id: NotRequired[builtins.str]
+    recipe_hash: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+    expires_at: NotRequired[builtins.str]
+    preview: NotRequired[_TasksGetResponseResultVariant17Variant1Preview]
+    preview_error: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewError]
+    pricing_option_id: NotRequired[builtins.str]
+    vendor_cost: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    consumption: NotRequired[_TasksGetResponseResultVariant17Variant1Consumption]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant17Variant2AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant17Variant2PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    creative_manifests: Required[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1 | _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2]]
+    sandbox: NotRequired[builtins.bool]
+    expires_at: NotRequired[builtins.str]
+    preview: NotRequired[_TasksGetResponseResultVariant17Variant2Preview]
+    preview_error: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewError]
+    pricing_option_id: NotRequired[builtins.str]
+    vendor_cost: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    consumption: NotRequired[_TasksGetResponseResultVariant17Variant2Consumption]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant17Variant3AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant17Variant3PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    creatives: Required[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItem]]
+    items_total: NotRequired[builtins.int]
+    items_returned: NotRequired[builtins.int]
+    leaves_total: NotRequired[builtins.int]
+    leaves_returned: NotRequired[builtins.int]
+    vendor_cost: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    keep_mode_applied: NotRequired[Literal['keep_all', 'keep_one', 'keep_some']]
+    selection_strategy_applied: NotRequired[Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random']]
+    budget_status: NotRequired[Literal['complete', 'capped']]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3ErrorsItem]]
+    sandbox: NotRequired[builtins.bool]
+    expires_at: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant4(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant17Variant4AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant17Variant4PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    mode: Required[Literal['estimate']]
+    estimate: Required[_TasksGetResponseResultVariant17Variant4Estimate]
+    expires_at: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant5(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant17Variant5AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant17Variant5PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: Required[builtins.list[_TasksGetResponseResultVariant17Variant5ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant6(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: Required[builtins.str]
+    status: Required[Literal['submitted']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant17Variant6AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant17Variant6PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant6ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant18(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant19(TypedDict, total=False):
+    reason: NotRequired[Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED']]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant19ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant20(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant20ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant1(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant21Variant1AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant21Variant1PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    dry_run: NotRequired[builtins.bool]
+    creatives: Required[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItem]]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant2(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant21Variant2AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant21Variant2PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: Required[builtins.list[_TasksGetResponseResultVariant21Variant2ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant3(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: Required[builtins.str]
+    status: Required[Literal['submitted']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant21Variant3AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant21Variant3PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant3ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant22(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    creatives_processed: NotRequired[builtins.int]
+    creatives_total: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant23(TypedDict, total=False):
+    reason: NotRequired[Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION']]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant24(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant24ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant25Variant1(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant25Variant1AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant25Variant1PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    dry_run: NotRequired[builtins.bool]
+    catalogs: Required[builtins.list[_TasksGetResponseResultVariant25Variant1CatalogsItem]]
+    sandbox: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant25Variant2(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: NotRequired[builtins.str]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant25Variant2AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant25Variant2PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: Required[builtins.list[_TasksGetResponseResultVariant25Variant2ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant25Variant3(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    context_id: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    task_id: Required[builtins.str]
+    status: Required[Literal['submitted']]
+    message: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    replayed: NotRequired[builtins.bool]
+    adcp_error: NotRequired[_TasksGetResponseResultVariant25Variant3AdcpError]
+    push_notification_config: NotRequired[_TasksGetResponseResultVariant25Variant3PushNotificationConfig]
+    governance_context: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant3ErrorsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant26(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+    catalogs_processed: NotRequired[builtins.int]
+    catalogs_total: NotRequired[builtins.int]
+    items_processed: NotRequired[builtins.int]
+    items_total: NotRequired[builtins.int]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant27(TypedDict, total=False):
+    reason: NotRequired[Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS']]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant28(TypedDict, total=False):
+    status: Required[Literal['submitted']]
+    task_id: Required[builtins.str]
+    message: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant28ErrorsItem]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _TasksListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_TasksListRequestAccountVariant2Brand]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _TasksListRequestFilters(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    protocols: NotRequired[builtins.list[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]]
+    status: NotRequired[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    statuses: NotRequired[builtins.list[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]]
+    task_type: NotRequired[Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']]
+    task_types: NotRequired[builtins.list[Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    task_ids: NotRequired[builtins.list[builtins.str]]
+    context_contains: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _TasksListRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_at', 'updated_at', 'status', 'task_type', 'protocol']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _TasksListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _TasksListResponseAdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksListResponseAdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksListResponsePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksListResponsePushNotificationConfigAuthentication]
+
+class _TasksListResponseQuerySummary(TypedDict, total=False):
+    total_matching: NotRequired[builtins.int]
+    returned: NotRequired[builtins.int]
+    domain_breakdown: NotRequired[_TasksListResponseQuerySummaryDomainBreakdown]
+    status_breakdown: NotRequired[builtins.dict[builtins.str, builtins.int]]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_TasksListResponseQuerySummarySortApplied]
+
+class _TasksListResponseTasksItem(TypedDict, total=False):
+    task_id: Required[builtins.str]
+    task_type: Required[Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']]
+    domain: Required[Literal['media-buy', 'signals', 'creative']]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    created_at: Required[builtins.str]
+    updated_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _TasksListResponsePagination(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _UpdateCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _UpdateContentStandardsRequestScope(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2]]
+
+class _UpdateMediaBuyRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateMediaBuyRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalMediaBuyPackageUpdate(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    budget: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bid_price: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[Literal[True]]
+    cancellation_reason: NotRequired[builtins.str]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    keyword_targets_add: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateKeywordTargetsAddItem]]
+    keyword_targets_remove: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateKeywordTargetsRemoveItem]]
+    negative_keywords_add: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateNegativeKeywordsAddItem]]
+    negative_keywords_remove: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateNegativeKeywordsRemoveItem]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    creatives: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateCreativesItemVariant1 | _ExternalMediaBuyPackageUpdateCreativesItemVariant2]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdatePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdatePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _UpdateRightsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateRightsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ValidateContentDeliveryRequestRecordsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    artifact: Required[_ExternalContentStandardsArtifact]
+    country: NotRequired[builtins.str]
+    channel: NotRequired[builtins.str]
+    brand_context: NotRequired[_ValidateContentDeliveryRequestRecordsItemBrandContext]
+
+class _ValidateContentDeliveryResponseSummary(TypedDict, total=False):
+    total_records: Required[builtins.int]
+    passed_records: Required[builtins.int]
+    failed_records: Required[builtins.int]
+
+class _ValidateContentDeliveryResponseResultsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    verdict: Required[Literal['pass', 'fail']]
+    features: NotRequired[builtins.list[_ValidateContentDeliveryResponseResultsItemFeaturesItem]]
+
+class _ValidateInputRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ValidateInputRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ValidateInputRequestManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ValidateInputRequestManifestVariant1FormatOptionRefVariant1 | _ValidateInputRequestManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidateInputRequestManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ValidateInputRequestManifestVariant2FormatOptionRefVariant1 | _ValidateInputRequestManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidateInputRequestTargetsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['canonical']]
+    id: Required[builtins.str]
+
+class _ValidateInputRequestTargetsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['product']]
+    id: Required[builtins.str]
+
+class _ValidateInputRequestTargetsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['third_party_format']]
+    id: Required[builtins.str]
+
+class _ExternalCreativeValidateInputResult(TypedDict, total=False):
+    target: Required[_ExternalCreativeValidateInputResultTarget]
+    result_kind: Required[Literal['validated_pass', 'validated_fail', 'unvalidatable_nondeterministic']]
+    violations: NotRequired[builtins.list[_ExternalCreativeValidateInputResultViolationsItem]]
+
+class _ValidatePropertyDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ValidatePropertyDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalPropertyDeliveryRecord(TypedDict, total=False):
+    identifier: Required[_ExternalCoreIdentifier]
+    impressions: Required[builtins.int]
+    record_id: NotRequired[builtins.str]
+    sales_agent_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidatePropertyDeliveryResponseSummary(TypedDict, total=False):
+    total_records: Required[builtins.int]
+    total_impressions: Required[builtins.int]
+    compliant_records: Required[builtins.int]
+    compliant_impressions: Required[builtins.int]
+    non_compliant_records: Required[builtins.int]
+    non_compliant_impressions: Required[builtins.int]
+    not_covered_records: Required[builtins.int]
+    not_covered_impressions: Required[builtins.int]
+    unidentified_records: Required[builtins.int]
+    unidentified_impressions: Required[builtins.int]
+
+class _ValidatePropertyDeliveryResponseAggregate(TypedDict, total=False):
+    score: NotRequired[builtins.float]
+    grade: NotRequired[builtins.str]
+    label: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _ValidatePropertyDeliveryResponseAuthorizationSummary(TypedDict, total=False):
+    records_checked: Required[builtins.int]
+    impressions_checked: Required[builtins.int]
+    authorized_records: Required[builtins.int]
+    authorized_impressions: Required[builtins.int]
+    unauthorized_records: Required[builtins.int]
+    unauthorized_impressions: Required[builtins.int]
+    unknown_records: Required[builtins.int]
+    unknown_impressions: Required[builtins.int]
+
+class _ExternalPropertyValidationResult(TypedDict, total=False):
+    identifier: Required[_ExternalCoreIdentifier]
+    record_id: NotRequired[builtins.str]
+    status: Required[Literal['compliant', 'non_compliant', 'not_covered', 'unidentified']]
+    impressions: Required[builtins.int]
+    features: NotRequired[builtins.list[_ExternalPropertyValidationResultFeaturesItem]]
+    authorization: NotRequired[_ExternalPropertyAuthorizationResult]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _VerifyBrandClaimRequestClaim(TypedDict, total=False):
+    subsidiary_domain: Required[builtins.str]
+    subsidiary_brand_id: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimRequestClaim2(TypedDict, total=False):
+    parent_domain: Required[builtins.str]
+    claimant_says: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimRequestClaim3(TypedDict, total=False):
+    property: Required[_VerifyBrandClaimRequestClaim3Property]
+    use_case: NotRequired[builtins.str]
+
+class _VerifyBrandClaimRequestClaim4(TypedDict, total=False):
+    mark: Required[builtins.str]
+    registry: NotRequired[builtins.str]
+    number: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    use_case: NotRequired[builtins.str]
+
+class _SignedResponse(TypedDict, total=False):
+    protected: Required[builtins.str]
+    payload: Required[_SignedResponsePayload]
+    signature: Required[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant1(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant1Claim]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant2(TypedDict, total=False):
+    claim_type: Required[Literal['parent']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant2Claim]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant3(TypedDict, total=False):
+    claim_type: Required[Literal['property']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant3Claim]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant4(TypedDict, total=False):
+    claim_type: Required[Literal['trademark']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant4Claim]
+
+class _VerifyBrandClaimsResponseResultsItemVariant1(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary', 'parent', 'property', 'trademark']]
+    status: Required[Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown']]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    context_note: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsResponseResultsItemVariant2(TypedDict, total=False):
+    error: Required[_ExternalCoreError]
+
+class _SignedResponse2(TypedDict, total=False):
+    protected: Required[builtins.str]
+    payload: Required[_SignedResponse2Payload]
+    signature: Required[builtins.str]
+
+class _ExternalCoreBrandRefDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreBrandRefBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_ExternalCoreAssetsImageAsset]
+    colors: NotRequired[_ExternalCoreBrandRefBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _ExternalCorePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalCoreErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_ExternalCoreErrorIssuesItemDiscriminatorItem]]
+
+class _ExternalBrandRightsTermsExclusivity(TypedDict, total=False):
+    scope: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRightsConstraintRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreIndustryIdentifier(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _ExternalCoreProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_ExternalCoreProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_ExternalCoreProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_ExternalCoreProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_ExternalCoreProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_ExternalCoreProvenanceWatermarksItem]]
+    disclosure: NotRequired[_ExternalCoreProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_ExternalCoreProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreFeatureRequirement(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    allowed_values: NotRequired[builtins.list[Any]]
+    if_not_covered: NotRequired[Literal['exclude', 'include']]
+    policy_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant1RankByItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    direction: NotRequired[Literal['maximize', 'minimize']]
+
+class _BuildCreativeRequestEvaluatorVariant1FeatureAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant1EvalBudget(TypedDict, total=False):
+    max_calls: NotRequired[builtins.int]
+    max_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeRequestEvaluatorVariant1Exemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _BuildCreativeRequestEvaluatorVariant2RankByItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    direction: NotRequired[Literal['maximize', 'minimize']]
+
+class _BuildCreativeRequestEvaluatorVariant2FeatureAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant2EvalBudget(TypedDict, total=False):
+    max_calls: NotRequired[builtins.int]
+    max_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeRequestEvaluatorVariant3RankByItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    direction: NotRequired[Literal['maximize', 'minimize']]
+
+class _BuildCreativeRequestEvaluatorVariant3FeatureAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant3EvalBudget(TypedDict, total=False):
+    max_calls: NotRequired[builtins.int]
+    max_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponsePreviewPreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1 | _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2 | _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3]]
+    input: Required[_BuildCreativeResponsePreviewPreviewsItemInput]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponsePreview2PreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    renders: Required[builtins.list[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1 | _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2 | _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3]]
+    input: Required[_BuildCreativeResponsePreview2PreviewsItemInput]
+
+class _BuildCreativeResponseCreativesItemCatalogItemRef(TypedDict, total=False):
+    catalog_type: NotRequired[builtins.str]
+    item_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _BuildCreativeResponseCreativesItemVariantsItem(TypedDict, total=False):
+    build_variant_id: Required[builtins.str]
+    recipe_hash: NotRequired[builtins.str]
+    parent_build_variant_id: NotRequired[builtins.str]
+    creative_manifest: Required[_BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1 | _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2]
+    variant_axis_value: NotRequired[Any]
+    recommended: NotRequired[builtins.bool]
+    rank: NotRequired[builtins.int]
+    eval: NotRequired[_BuildCreativeResponseCreativesItemVariantsItemEval]
+    pricing_option_id: NotRequired[builtins.str]
+    vendor_cost: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    consumption: NotRequired[_ExternalCoreCreativeConsumption]
+
+class _BuildCreativeResponseEstimatePerLeafItem(TypedDict, total=False):
+    catalog_item_ref: NotRequired[builtins.dict[builtins.str, Any]]
+    variant_axis_value: NotRequired[Any]
+    pricing_option_id: NotRequired[builtins.str]
+    cost_low: NotRequired[builtins.float]
+    cost_high: NotRequired[builtins.float]
+    consumption_estimate: NotRequired[_ExternalCoreCreativeConsumption]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactMetadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _ExternalContentStandardsArtifactIdentifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalCorePlannedDeliveryGeo(TypedDict, total=False):
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreFrequencyCap(TypedDict, total=False):
+    suppress: NotRequired[_ExternalCoreFrequencyCapSuppress]
+    suppress_minutes: NotRequired[builtins.float]
+    max_impressions: NotRequired[builtins.int]
+    per: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    window: NotRequired[_ExternalCoreFrequencyCapWindow]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _CheckGovernanceRequestDeliveryMetricsReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _CheckGovernanceRequestDeliveryMetricsAudienceDistribution(TypedDict, total=False):
+    baseline: Required[Literal['census', 'platform', 'custom']]
+    baseline_description: NotRequired[builtins.str]
+    indices: Required[builtins.dict[builtins.str, builtins.float]]
+    cumulative_indices: NotRequired[builtins.dict[builtins.str, builtins.float]]
+
+class _ExternalCoreBusinessEntityAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _ExternalCoreBusinessEntityContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _ExternalCoreBusinessEntityBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _ComplyTestControllerRequestParamsReportedSpend(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ComplyTestControllerRequestParamsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ComplyTestControllerRequestParamsReachWindowPeriod]
+
+class _ComplyTestControllerRequestParamsViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ComplyTestControllerRequestParamsMetricsItem(TypedDict, total=False):
+    metric_id: Required[builtins.str]
+
+class _ExternalCreativeAuditObservationDetails(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+    claimed_value: Required[_ExternalCreativeAuditObservationDetailsClaimedValue]
+    observed_value: NotRequired[builtins.bool | builtins.float | builtins.str | None]
+    confidence: NotRequired[builtins.float]
+    substituted_for: NotRequired[builtins.str]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant1IdentifierMatchProofsItem(TypedDict, total=False):
+    identifier_value_sha256: Required[builtins.str]
+    found: Required[builtins.bool]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant2IdentifierMatchProofsItem(TypedDict, total=False):
+    identifier_value_sha256: Required[builtins.str]
+    found: Required[builtins.bool]
+
+class _ContextMatchRequestGeoMetro(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    value: Required[builtins.str]
+
+class _ExternalCoreSellerAgentRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: NotRequired[builtins.str]
+
+class _ExternalTrustedMatchOfferPrice(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: NotRequired[builtins.str]
+    model: Required[Literal['cpm', 'cpc', 'cpcv', 'cpa', 'flat']]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant1 | _ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant1 | _ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ContextMatchResponseSignalsTargetingKvsItem(TypedDict, total=False):
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _ExternalCoreContentRating(TypedDict, total=False):
+    system: Required[Literal['tv_parental', 'mpaa', 'podcast', 'esrb', 'bbfc', 'fsk', 'acb', 'chvrs', 'csa', 'pegi', 'custom']]
+    rating: Required[builtins.str]
+
+class _ExternalCollectionCollectionListFiltersExcludeDistributionIdsItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _ExternalCollectionCollectionListAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalCollectionCollectionListAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_ExternalCollectionCollectionListBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _ExternalGovernancePolicyEntryExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_Exemplar]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant1(TypedDict, total=False):
+    type: Required[Literal['url']]
+    value: Required[builtins.str]
+    language: NotRequired[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4]]
+    metadata: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers]
+
+class _ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant2 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1Qualifier]
+
+class _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant1 | _ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant1 | _ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalCoreReportingWebhookAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _CreateMediaBuyRequestArtifactWebhookAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalCoreAccountCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAccountSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _ExternalCoreAccountReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _ExternalCoreNotificationConfig(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['scheduled', 'final', 'delayed', 'adjusted', 'impairment', 'creative.status_changed', 'creative.purged', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    authentication: NotRequired[_ExternalCoreNotificationConfigAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreSlaWindow(TypedDict, total=False):
+    response_max: NotRequired[builtins.str]
+    completion_max: NotRequired[builtins.str]
+
+class _ExternalPricingOptionsPriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant1 | _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant2]]
+
+class _ExternalCorePackageFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCorePackageFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCorePackageCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_ExternalCorePackageCommittedMetricsItemVariant1Qualifier]
+    committed_at: Required[builtins.str]
+
+class _ExternalCorePackageCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    committed_at: Required[builtins.str]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalCorePackageOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant2 | _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+    acknowledged_at: NotRequired[builtins.str]
+
+class _ExternalPropertyPropertyListAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalPropertyPropertyListAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalPropertyPropertyListPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetAccountFinancialsResponseBalanceLastTopUp(TypedDict, total=False):
+    amount: Required[builtins.float]
+    date: Required[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant1(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    replay_ttl_seconds: Required[builtins.int]
+    in_flight_max_seconds: NotRequired[builtins.int]
+    account_id_is_opaque: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant2(TypedDict, total=False):
+    supported: Required[Literal[False]]
+
+class _ExternalCoreMediaBuyFeatures(TypedDict, total=False):
+    inline_creative_management: NotRequired[builtins.bool]
+    property_list_filtering: NotRequired[builtins.bool]
+    catalog_management: NotRequired[builtins.bool]
+    committed_metrics_supported: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecution(TypedDict, total=False):
+    trusted_match: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTrustedMatch]
+    axe_integrations: NotRequired[builtins.list[builtins.str]]
+    creative_specs: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionCreativeSpecs]
+    targeting: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargeting]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceTargeting(TypedDict, total=False):
+    supported_identifier_types: Required[builtins.list[Literal['hashed_email', 'hashed_phone']]]
+    supports_platform_customer_id: NotRequired[builtins.bool]
+    supported_uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+    minimum_audience_size: Required[builtins.int]
+    matching_latency_hours: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceTargetingMatchingLatencyHours]
+
+class _GetAdcpCapabilitiesResponseMediaBuyVendorMetricOptimization(TypedDict, total=False):
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyConversionTracking(TypedDict, total=False):
+    multi_source_event_dedup: NotRequired[builtins.bool]
+    per_creative_attribution: NotRequired[builtins.bool]
+    supported_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    supported_uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+    supported_hashed_identifiers: NotRequired[builtins.list[Literal['hashed_email', 'hashed_phone']]]
+    supported_action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    attribution_windows: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseMediaBuyConversionTrackingAttributionWindowsItem]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyFrequencyCapping(TypedDict, total=False):
+    supported_per_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_window_units: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyContentStandards(TypedDict, total=False):
+    supports_local_evaluation: NotRequired[builtins.bool]
+    supported_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    supports_webhook_delivery: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyPortfolio(TypedDict, total=False):
+    publisher_domains: Required[builtins.list[builtins.str]]
+    primary_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    primary_countries: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    advertising_policies: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseSignalsFeatures(TypedDict, total=False):
+    catalog_signals: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    type: Required[Literal['binary', 'quantitative', 'categorical']]
+    range: NotRequired[_GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItemRange]
+    categories: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    type: Required[Literal['binary', 'quantitative', 'categorical']]
+    range: NotRequired[_GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItemRange]
+    categories: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpoint(TypedDict, total=False):
+    transports: Required[builtins.list[_GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpointTransportsItem]]
+    preferred: NotRequired[Literal['mcp', 'a2a']]
+
+class _GetAdcpCapabilitiesResponseCreativeMultiplicity(TypedDict, total=False):
+    supports_catalog_fanout: NotRequired[builtins.bool]
+    max_creatives_limit: NotRequired[builtins.int]
+    supports_signal_fanout: NotRequired[builtins.bool]
+    max_signal_conditions_limit: NotRequired[builtins.int]
+    supports_variants: NotRequired[builtins.bool]
+    max_variants_limit: NotRequired[builtins.int]
+    variant_dimensions: NotRequired[builtins.list[Literal['voice', 'theme', 'best_of_n', 'transformer_config', 'custom']]]
+    selection_strategies: NotRequired[builtins.list[Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random']]]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItem(TypedDict, total=False):
+    capability_id: NotRequired[builtins.str]
+    format: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant4 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant5 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant6 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant7 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant8 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant9 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant10 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant11 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant12 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant13]
+
+class _GetAdcpCapabilitiesResponseIdentityKeyOrigins(TypedDict, total=False):
+    governance_signing: NotRequired[builtins.str]
+    request_signing: NotRequired[builtins.str]
+    webhook_signing: NotRequired[builtins.str]
+    tmp_signing: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseIdentityCompromiseNotification(TypedDict, total=False):
+    emits: NotRequired[builtins.bool]
+    accepts: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMeasurementMetricsItem(TypedDict, total=False):
+    metric_id: Required[builtins.str]
+    standard_reference: NotRequired[builtins.str]
+    accreditations: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseMeasurementMetricsItemAccreditationsItem]]
+    unit: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    methodology_version: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _FontRoleVariant2(TypedDict, total=False):
+    family: Required[builtins.str]
+    files: NotRequired[builtins.list[_FontRoleVariant2FilesItem]]
+    opentype_features: NotRequired[builtins.list[builtins.str]]
+    fallbacks: NotRequired[builtins.list[builtins.str]]
+
+class _GetCollectionListResponseCollectionsItemDistributionIdsItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreDeliveryMetrics(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreDeliveryMetricsQuartileData | _ExternalCoreDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+
+class _ExternalCoreCreativeVariant(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCreativeVariantByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreCreativeVariantReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCreativeVariantQuartileData | _ExternalCoreCreativeVariantQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreCreativeVariantDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCreativeVariantViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCreativeVariantByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    variant_id: Required[builtins.str]
+    manifest: NotRequired[_ExternalCoreCreativeVariantManifestVariant1 | _ExternalCoreCreativeVariantManifestVariant2]
+    generation_context: NotRequired[_ExternalCoreCreativeVariantGenerationContext]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _GetMediaBuyArtifactsResponseArtifactsItemBrandContext(TypedDict, total=False):
+    brand_id: NotRequired[builtins.str]
+    sku_id: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryRequestAttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryRequestAttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsGeo(TypedDict, total=False):
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom', 'postal_code', 'zip', 'zip_plus_four', 'outward', 'full', 'fsa', 'plz', 'code_postal', 'postcode', 'cep', 'pin', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    country: NotRequired[builtins.str]
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDeviceType(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDevicePlatform(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsAudience(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsPlacement(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _ExternalCoreAttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreAttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1Qualifier]
+    value: Required[builtins.float]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    qualifier: NotRequired[builtins.dict[builtins.str, Any]]
+    value: Required[builtins.float]
+    measurable_impressions: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotals(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    effective_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    package_id: Required[builtins.str]
+    pacing_index: NotRequired[builtins.float]
+    pricing_model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    rate: Required[builtins.float]
+    currency: Required[builtins.str]
+    delivery_status: NotRequired[Literal['delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    paused: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    measurement_window: NotRequired[builtins.str]
+    supersedes_window: NotRequired[builtins.str]
+    missing_metrics: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1 | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant2]]
+    by_catalog_item: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetrics]]
+    by_creative: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetrics]]
+    by_keyword: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetrics]]
+    by_geo: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetrics]]
+    by_geo_truncated: NotRequired[builtins.bool]
+    by_device_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItem]]
+    by_device_type_truncated: NotRequired[builtins.bool]
+    by_device_platform: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItem]]
+    by_device_platform_truncated: NotRequired[builtins.bool]
+    by_audience: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItem]]
+    by_audience_truncated: NotRequired[builtins.bool]
+    by_placement: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItem]]
+    by_placement_truncated: NotRequired[builtins.bool]
+    daily_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDailyBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItem(TypedDict, total=False):
+    window_start: Required[builtins.str]
+    window_end: Required[builtins.str]
+    totals: Required[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotals]
+    by_package: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItem]]
+    is_final: NotRequired[builtins.bool]
+    measurement_window: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemDailyBreakdownItem(TypedDict, total=False):
+    date: Required[builtins.str]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+
+class _ExternalCoreImpairment(TypedDict, total=False):
+    impairment_id: Required[builtins.str]
+    resource_type: Required[Literal['audience', 'creative', 'catalog_item', 'event_source', 'property']]
+    resource_id: Required[builtins.str]
+    package_ids: Required[builtins.list[builtins.str]]
+    transition: Required[_ExternalCoreImpairmentTransition]
+    reason_code: Required[Literal['policy_violation', 'consent_expired', 'ttl_expired', 'pii_audit_failed', 'seller_removed', 'content_rejected', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_offline', 'property_depublished']]
+    reason: NotRequired[builtins.str]
+    observed_at: Required[builtins.str]
+    remediation: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+
+class _ExternalCoreWebhookActivityRecord(TypedDict, total=False):
+    idempotency_key: Required[builtins.str]
+    subscriber_id: NotRequired[builtins.str]
+    fired_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str | None]
+    notification_type: Required[Literal['scheduled', 'final', 'delayed', 'adjusted', 'impairment', 'creative.status_changed', 'creative.purged', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]
+    sequence_number: NotRequired[builtins.int]
+    attempt: Required[builtins.int]
+    status: Required[Literal['success', 'failed', 'timeout', 'connection_error', 'pending']]
+    url: Required[builtins.str]
+    http_status_code: NotRequired[builtins.int | None]
+    response_time_ms: NotRequired[builtins.int | None]
+    payload_size_bytes: NotRequired[builtins.int]
+    error_message: NotRequired[builtins.str | None]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuysResponseMediaBuysItemHistoryItem(TypedDict, total=False):
+    revision: Required[builtins.int]
+    timestamp: Required[builtins.str]
+    actor: NotRequired[builtins.str]
+    action: Required[builtins.str]
+    summary: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_option_refs: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    impressions: NotRequired[builtins.float]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemCancellation]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    creative_approvals: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemCreativeApprovalsItem]]
+    format_ids_pending: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    snapshot: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemSnapshot]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemBudget(TypedDict, total=False):
+    authorized: NotRequired[builtins.float]
+    committed: NotRequired[builtins.float]
+    remaining: NotRequired[builtins.float]
+    utilization_pct: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemChannelAllocationValue(TypedDict, total=False):
+    committed: NotRequired[builtins.float]
+    pct: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemSummary(TypedDict, total=False):
+    checks_performed: NotRequired[builtins.int]
+    outcomes_reported: NotRequired[builtins.int]
+    statuses: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryStatuses]
+    findings_count: NotRequired[builtins.int]
+    escalations: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemSummaryEscalationsItem]]
+    drift_metrics: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryDriftMetrics]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    type: Required[Literal['check', 'outcome']]
+    timestamp: Required[builtins.str]
+    plan_id: NotRequired[builtins.str]
+    caller: NotRequired[builtins.str]
+    tool: NotRequired[builtins.str]
+    verdict: NotRequired[Literal['approved', 'denied', 'conditions']]
+    check_type: NotRequired[Literal['intent', 'execution']]
+    mode: NotRequired[Literal['audit', 'advisory', 'enforce']]
+    explanation: NotRequired[builtins.str]
+    policies_evaluated: NotRequired[builtins.list[builtins.str]]
+    categories_evaluated: NotRequired[builtins.list[builtins.str]]
+    findings: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItemFindingsItem]]
+    outcome: NotRequired[Literal['completed', 'failed', 'delivery']]
+    committed_budget: NotRequired[builtins.float]
+    governance_context: NotRequired[builtins.str]
+    plan_hash: NotRequired[builtins.str]
+    purchase_type: NotRequired[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']]
+    outcome_status: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemGovernedActionsItem(TypedDict, total=False):
+    governance_context: Required[builtins.str]
+    purchase_type: Required[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']]
+    status: Required[Literal['active', 'suspended', 'completed']]
+    committed: Required[builtins.float]
+    check_count: Required[builtins.int]
+    seller_reference: NotRequired[builtins.str]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant1(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant2(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant3(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['by_tag']]
+    property_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1 | _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2 | _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3 | _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4]
+
+class _ExternalCoreProductFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1 | _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2 | _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3 | _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4]
+
+class _ExternalCoreProductFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1 | _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2 | _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3 | _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4]
+
+class _ExternalCoreProductFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCoreProductFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCoreProductFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCoreProductFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCoreProductFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCoreProductFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCoreProductFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCoreProductFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCoreProductFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCoreProductFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePlacement(TypedDict, total=False):
+    kind: Required[Literal['publisher_ref', 'seller_inline']]
+    placement_id: Required[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    mode: Required[Literal['targetable', 'included']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_options: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1 | _ExternalCorePlacementFormatOptionsItemVariant2 | _ExternalCorePlacementFormatOptionsItemVariant3 | _ExternalCorePlacementFormatOptionsItemVariant4 | _ExternalCorePlacementFormatOptionsItemVariant5 | _ExternalCorePlacementFormatOptionsItemVariant6 | _ExternalCorePlacementFormatOptionsItemVariant7 | _ExternalCorePlacementFormatOptionsItemVariant8 | _ExternalCorePlacementFormatOptionsItemVariant9 | _ExternalCorePlacementFormatOptionsItemVariant10 | _ExternalCorePlacementFormatOptionsItemVariant11 | _ExternalCorePlacementFormatOptionsItemVariant12 | _ExternalCorePlacementFormatOptionsItemVariant13]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['vcpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpc']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpcv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant5Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant6(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpp']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant6Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant7(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpa']]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    fixed_price: Required[builtins.float]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant8(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['flat_rate']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: NotRequired[_ExternalCoreProductPricingOptionsItemVariant8Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant9(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['time']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant9Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreDeliveryForecast(TypedDict, total=False):
+    points: Required[builtins.list[_ExternalCoreForecastPoint]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreOutcomeMeasurement(TypedDict, total=False):
+    type: Required[builtins.str]
+    attribution: Required[builtins.str]
+    window: NotRequired[_ExternalCoreOutcomeMeasurementWindow]
+    reporting: Required[builtins.str]
+
+class _ExternalCoreProductDeliveryMeasurement(TypedDict, total=False):
+    vendors: NotRequired[builtins.list[_ExternalCoreBrandRef]]
+    provider: NotRequired[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _ExternalCoreCancellationPolicy(TypedDict, total=False):
+    notice_period: Required[_ExternalCoreDuration]
+    cancellation_fee: Required[_ExternalCoreCancellationPolicyCancellationFee]
+
+class _ExternalCoreProductAllowedAction(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    modes: Required[builtins.list[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]]
+    allowed_statuses: NotRequired[builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ExternalCoreReportingCapabilities(TypedDict, total=False):
+    available_reporting_frequencies: Required[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    expected_delay_minutes: Required[builtins.int]
+    timezone: Required[builtins.str]
+    supports_webhooks: Required[builtins.bool]
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    vendor_metrics: NotRequired[builtins.list[_ExternalCoreReportingCapabilitiesVendorMetricsItem]]
+    supports_creative_breakdown: NotRequired[builtins.bool]
+    supports_keyword_breakdown: NotRequired[builtins.bool]
+    supports_geo_breakdown: NotRequired[_ExternalCoreGeoBreakdownSupport]
+    supports_device_type_breakdown: NotRequired[builtins.bool]
+    supports_device_platform_breakdown: NotRequired[builtins.bool]
+    supports_audience_breakdown: NotRequired[builtins.bool]
+    supports_placement_breakdown: NotRequired[builtins.bool]
+    date_range_support: Required[Literal['date_range', 'lifetime_only']]
+    windowed_pull_granularities: NotRequired[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    measurement_windows: NotRequired[builtins.list[_ExternalCoreMeasurementWindow]]
+
+class _ExternalCoreCreativePolicy(TypedDict, total=False):
+    co_branding: Required[Literal['required', 'optional', 'none']]
+    landing_page: Required[Literal['any', 'retailer_site_only', 'must_include_retailer']]
+    templates_available: Required[builtins.bool]
+    provenance_required: NotRequired[builtins.bool]
+    provenance_requirements: NotRequired[_ExternalCoreCreativePolicyProvenanceRequirements]
+    accepted_verifiers: NotRequired[builtins.list[_ExternalCoreCreativePolicyAcceptedVerifiersItem]]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant1(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant2(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    signal_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant3(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_tag']]
+    signal_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreSignalListing(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreSignalListingSignalRefVariant1 | _ExternalCoreSignalListingSignalRefVariant2 | _ExternalCoreSignalListingSignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreSignalListingSignalIdVariant1 | _ExternalCoreSignalListingSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_ExternalCoreSignalListingRange]
+
+class _ExternalCoreProductSignalTargetingOption(TypedDict, total=False):
+    signal_ref: Required[_ExternalCoreProductSignalTargetingOptionSignalRefVariant1 | _ExternalCoreProductSignalTargetingOptionSignalRefVariant2 | _ExternalCoreProductSignalTargetingOptionSignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductSignalTargetingOptionSignalIdVariant1 | _ExternalCoreProductSignalTargetingOptionSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_ExternalCoreProductSignalTargetingOptionRange]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_status: NotRequired[Literal['ready', 'requires_activation']]
+    allowed_targeting_modes: NotRequired[builtins.list[Literal['include', 'exclude']]]
+    default_selected: NotRequired[builtins.bool]
+    selection_group: NotRequired[builtins.str]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant1 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant2 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant3 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant4 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5]]
+
+class _ExternalCoreSignalTargetingRules(TypedDict, total=False):
+    resolution_model: NotRequired[Literal['direct_targeting', 'seller_planned']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+    max_selected_per_group: NotRequired[builtins.int]
+    max_signal_targeting_groups: NotRequired[builtins.int]
+    max_signals_per_targeting_group: NotRequired[builtins.int]
+    selection_group_rules: NotRequired[builtins.list[_ExternalCoreSignalSelectionGroupRule]]
+
+class _ExternalCoreProductMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    supported_reach_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_view_durations: NotRequired[builtins.list[builtins.float]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _ExternalCoreVendorMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[_ExternalCoreVendorMetricOptimizationSupportedMetric]]
+
+class _ExternalCoreMeasurementReadiness(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    required_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    missing_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    issues: NotRequired[builtins.list[_ExternalCoreDiagnosticIssue]]
+    notes: NotRequired[builtins.str]
+
+class _ExternalCoreProductConversionTracking(TypedDict, total=False):
+    action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    platform_managed: NotRequired[builtins.bool]
+
+class _ExternalCoreProductCatalogMatch(TypedDict, total=False):
+    matched_gtins: NotRequired[builtins.list[builtins.str]]
+    matched_ids: NotRequired[builtins.list[builtins.str]]
+    matched_count: NotRequired[builtins.int]
+    submitted_count: Required[builtins.int]
+
+class _ExternalCoreProductProductCard(TypedDict, total=False):
+    image: NotRequired[_ExternalCoreAssetsImageAsset]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _ExternalCoreProductProductCardDetailed(TypedDict, total=False):
+    hero_image: NotRequired[_ExternalCoreAssetsImageAsset]
+    carousel_images: NotRequired[builtins.list[_ExternalCoreAssetsImageAsset]]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    specifications: NotRequired[builtins.list[_ExternalCoreProductProductCardDetailedSpecificationsItem]]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _ExternalCoreCollectionSelector(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreInstallment(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    collection_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    season: NotRequired[builtins.str]
+    installment_number: NotRequired[builtins.str]
+    scheduled_at: NotRequired[builtins.str]
+    status: NotRequired[Literal['scheduled', 'tentative', 'live', 'postponed', 'cancelled', 'aired', 'published']]
+    duration_seconds: NotRequired[builtins.int]
+    flexible_end: NotRequired[builtins.bool]
+    valid_until: NotRequired[builtins.str]
+    content_rating: NotRequired[_ExternalCoreContentRating]
+    topics: NotRequired[builtins.list[builtins.str]]
+    special: NotRequired[_ExternalCoreSpecial]
+    guest_talent: NotRequired[builtins.list[_ExternalCoreTalent]]
+    ad_inventory: NotRequired[_ExternalCoreAdInventoryConfig]
+    deadlines: NotRequired[_ExternalCoreInstallmentDeadlines]
+    derivative_of: NotRequired[_ExternalCoreInstallmentDerivativeOf]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTrustedMatch(TypedDict, total=False):
+    context_match: Required[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+    dynamic_brands: NotRequired[builtins.bool]
+    providers: NotRequired[builtins.list[_ExternalCoreProductTrustedMatchProvidersItem]]
+
+class _ExternalCoreProductMaterialSubmission(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    instructions: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCatalogFieldMapping(TypedDict, total=False):
+    feed_field: NotRequired[builtins.str]
+    catalog_field: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    value: NotRequired[Any]
+    transform: NotRequired[Literal['date', 'divide', 'boolean', 'split']]
+    format: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    by: NotRequired[builtins.float]
+    separator: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductFiltersBudgetRange(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreProductFiltersMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    code: Required[builtins.str]
+
+class _ExternalCoreProductFiltersTrustedMatch(TypedDict, total=False):
+    providers: NotRequired[builtins.list[_ExternalCoreProductFiltersTrustedMatchProvidersItem]]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+
+class _ExternalCoreProductFiltersRequiredGeoTargetingItem(TypedDict, total=False):
+    level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    country: NotRequired[builtins.str]
+    system: NotRequired[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_ExternalCoreProductFiltersGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant1Geometry]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_ExternalCoreProductFiltersGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant2Geometry]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant3Radius]
+    geometry: Required[_ExternalCoreProductFiltersGeoProximityItemVariant3Geometry]
+
+class _ExternalCoreProductFiltersRequiredVendorMetricsItem(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    metric_id: NotRequired[builtins.str]
+
+class _ExternalCoreProductFiltersKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: NotRequired[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreProductAllocation(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    allocation_percentage: Required[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    rationale: NotRequired[builtins.str]
+    sequence: NotRequired[builtins.int]
+    tags: NotRequired[builtins.list[builtins.str]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    daypart_targets: NotRequired[builtins.list[_ExternalCoreDaypartTarget]]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreInsertionOrder(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    terms: NotRequired[_ExternalCoreInsertionOrderTerms]
+    terms_url: NotRequired[builtins.str]
+    signing_url: NotRequired[builtins.str]
+    requires_signature: Required[builtins.bool]
+
+class _ExternalCoreProposalTotalBudgetGuidance(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    recommended: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _GetProductsResponseIncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetProductsResponseFilterDiagnosticsExcludedByValue(TypedDict, total=False):
+    count: Required[builtins.int]
+    values: NotRequired[builtins.list[builtins.str | builtins.dict[builtins.str, Any]]]
+    notes: NotRequired[builtins.str]
+
+class _GetRightsResponseRightsItemExclusivityStatus(TypedDict, total=False):
+    available: NotRequired[builtins.bool]
+    existing_exclusives: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalBrandRightsPricingOption(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    price: Required[builtins.float]
+    currency: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    period: NotRequired[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual', 'one_time']]
+    impression_cap: NotRequired[builtins.int]
+    overage_cpm: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetRightsResponseRightsItemPreviewAssetsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    usage: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Never]
+    signal_id: Required[builtins.str]
+    data_provider_domain: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Never]
+    signal_id: Required[builtins.str]
+    signal_source_url: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant4(TypedDict, total=False):
+    scope: Required[Never]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant5(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant6(TypedDict, total=False):
+    scope: Required[Never]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+    signal_source_url: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant7(TypedDict, total=False):
+    scope: Required[Never]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant8(TypedDict, total=False):
+    scope: Required[Never]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+    data_provider_domain: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant9(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetSignalsResponseSignalsItemTaxonomy(TypedDict, total=False):
+    ref: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    segtax: NotRequired[builtins.int]
+    etag: NotRequired[builtins.str]
+    values: Required[builtins.list[_GetSignalsResponseSignalsItemTaxonomyValuesItem]]
+    value_mappings: NotRequired[builtins.list[_GetSignalsResponseSignalsItemTaxonomyValueMappingsItem]]
+    parent_match_behavior: NotRequired[Literal['exact_only', 'descendants_supported', 'unknown']]
+
+class _GetSignalsResponseSignalsItemOnboarder(TypedDict, total=False):
+    match_keys: Required[builtins.list[Literal['name', 'address', 'email', 'postal', 'lat_long', 'mobile_id', 'cookie_id', 'ip', 'customer_id', 'phone']]]
+    pre_onboarding_audience_expansion: NotRequired[builtins.bool]
+    pre_onboarding_device_expansion: NotRequired[builtins.bool]
+    pre_onboarding_precision_level: NotRequired[Literal['individual', 'household', 'business', 'geography']]
+
+class _GetSignalsResponseSignalsItemModeling(TypedDict, total=False):
+    method: Required[Literal['lookalike', 'supervised', 'embedding', 'rules']]
+    seed_source: Required[_GetSignalsResponseSignalsItemModelingSeedSource]
+    training_data_jurisdictions: Required[builtins.list[builtins.str]]
+    ai_act_risk_class: Required[Literal['minimal', 'limited', 'high_risk']]
+    disclosure: NotRequired[_ExternalCoreSignalModelingDisclosure]
+
+class _GetSignalsResponseSignalsItemDataSubjectRights(TypedDict, total=False):
+    upstream_source_domain: NotRequired[builtins.str]
+    channels: Required[builtins.list[_GetSignalsResponseSignalsItemDataSubjectRightsChannelsItem]]
+    response_sla_days: NotRequired[builtins.int]
+    ccpa_opt_out_url: NotRequired[builtins.str]
+
+class _ExternalCoreSignalCoverageForecast(TypedDict, total=False):
+    points: Required[builtins.list[_ExternalCoreSignalCoverageForecastPointsItem]]
+    forecast_range_unit: Required[Literal['availability']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    scope: Required[_ExternalCoreSignalCoverageForecastScope]
+    bucket_semantics: Required[Literal['exclusive', 'overlapping']]
+    bucket_completeness: Required[Literal['complete', 'partial']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_GetSignalsResponseSignalsItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseIncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetTaskStatusResponseErrorDetails(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    operation: NotRequired[builtins.str]
+    specific_context: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _IdentityMatchRequestIdentitiesItemAttestation(TypedDict, total=False):
+    issuer: Required[_ExternalCoreBrandRef]
+    scheme: Required[builtins.str]
+    relying_party_id: NotRequired[builtins.str]
+    action: NotRequired[builtins.str]
+    claims: Required[builtins.list[Literal['unique_human', 'age_over_13', 'age_over_16', 'age_over_18', 'age_over_21']]]
+    verification_level: NotRequired[Literal['orb', 'device', 'document']]
+    signal_binding: NotRequired[builtins.str]
+    proof: Required[builtins.dict[builtins.str, Any]]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _ExternalCoreAccountAuthorization(TypedDict, total=False):
+    allowed_tasks: Required[builtins.list[builtins.str]]
+    field_scopes: NotRequired[builtins.dict[builtins.str, builtins.list[builtins.str]]]
+    scope_name: NotRequired[Literal['attestation_verifier'] | builtins.str]
+    read_only: NotRequired[builtins.bool]
+
+class _ExternalContentStandardsContentStandardsCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalContentStandardsContentStandardsPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatRendersItemVariant1(TypedDict, total=False):
+    role: Required[builtins.str]
+    parameters_from_format_id: NotRequired[builtins.bool]
+    dimensions: Required[_ExternalCoreFormatRendersItemVariant1Dimensions]
+
+class _ExternalCoreFormatRendersItemVariant2(TypedDict, total=False):
+    role: Required[builtins.str]
+    parameters_from_format_id: Required[Literal[True]]
+    dimensions: NotRequired[_ExternalCoreFormatRendersItemVariant2Dimensions]
+
+class _ExternalCoreFormatAssetsItemVariant1(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['image']]
+    requirements: NotRequired[_ExternalCoreRequirementsImageAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant2(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['video']]
+    requirements: NotRequired[_ExternalCoreRequirementsVideoAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant3(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['audio']]
+    requirements: NotRequired[_ExternalCoreRequirementsAudioAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant4(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['text']]
+    requirements: NotRequired[_ExternalCoreRequirementsTextAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant5(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['markdown']]
+    requirements: NotRequired[_ExternalCoreRequirementsMarkdownAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant6(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['html']]
+    requirements: NotRequired[_ExternalCoreRequirementsHtmlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant7(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['css']]
+    requirements: NotRequired[_ExternalCoreRequirementsCssAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant8(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['javascript']]
+    requirements: NotRequired[_ExternalCoreRequirementsJavascriptAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant9(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['zip']]
+
+class _ExternalCoreFormatAssetsItemVariant10(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['vast']]
+    requirements: NotRequired[_ExternalCoreRequirementsVastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant11(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['daast']]
+    requirements: NotRequired[_ExternalCoreRequirementsDaastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant12(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['url']]
+    requirements: NotRequired[_ExternalCoreRequirementsUrlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant13(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['webhook']]
+    requirements: NotRequired[_ExternalCoreRequirementsWebhookAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant14(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['brief']]
+
+class _ExternalCoreFormatAssetsItemVariant15(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['catalog']]
+    requirements: NotRequired[_ExternalCoreRequirementsCatalogRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16(TypedDict, total=False):
+    item_type: Required[Literal['repeatable_group']]
+    asset_group_id: Required[builtins.str]
+    required: Required[builtins.bool]
+    min_count: Required[builtins.int]
+    max_count: Required[builtins.int]
+    selection_mode: NotRequired[Literal['sequential', 'optimize']]
+    assets: Required[builtins.list[_ExternalCoreFormatAssetsItemVariant16AssetsItemVariant1 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant2 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant3 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant4 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant5 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant6 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant7 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant8 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant9 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant10 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant11 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant12 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant13]]
+
+class _ExternalCoreFormatFormatCard(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatAccessibility(TypedDict, total=False):
+    wcag_level: Required[Literal['A', 'AA', 'AAA']]
+    requires_accessible_assets: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatDisclosureCapabilitiesItem(TypedDict, total=False):
+    position: Required[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]
+    persistence: Required[builtins.list[Literal['continuous', 'initial', 'flexible']]]
+
+class _ExternalCoreFormatFormatCardDetailed(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreFormatPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalProjectionRef(TypedDict, total=False):
+    kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    slots_override: NotRequired[builtins.list[_ExternalCoreCanonicalProjectionSlotOverride]]
+
+class _ExternalCoreFormatCanonicalParametersVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1 | _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2 | _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3 | _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4]
+
+class _ExternalCoreFormatCanonicalParametersVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1 | _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2 | _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3 | _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4]
+
+class _ExternalCoreFormatCanonicalParametersVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1 | _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2 | _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3 | _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4]
+
+class _ExternalCoreFormatCanonicalParametersVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCoreFormatCanonicalParametersVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCoreFormatCanonicalParametersVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCoreFormatCanonicalParametersVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCoreFormatCanonicalParametersVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCoreFormatCanonicalParametersVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCoreFormatCanonicalParametersVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCoreFormatCanonicalParametersVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCoreFormatCanonicalParametersVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCoreFormatCanonicalParametersVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeFiltersAccountsItemVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalCoreCreativeFiltersAccountsItemVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListCreativesResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: NotRequired[builtins.str]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreCreativeVariable(TypedDict, total=False):
+    variable_id: Required[builtins.str]
+    name: Required[builtins.str]
+    variable_type: Required[Literal['text', 'image', 'video', 'audio', 'url', 'number', 'boolean', 'color', 'date']]
+    default_value: NotRequired[builtins.str]
+    required: NotRequired[builtins.bool]
+
+class _ListCreativesResponseCreativesItemVariant1Assignments(TypedDict, total=False):
+    assignment_count: Required[builtins.int]
+    assigned_packages: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant1AssignmentsAssignedPackagesItem]]
+
+class _ListCreativesResponseCreativesItemVariant1Snapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.int]
+    last_served: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1ItemsItemVariant1(TypedDict, total=False):
+    asset_kind: Required[Literal['media']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content_uri: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1ItemsItemVariant2(TypedDict, total=False):
+    asset_kind: Required[Literal['text']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content: Required[builtins.str | builtins.list[builtins.str]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1Purge(TypedDict, total=False):
+    kind: Required[Literal['soft']]
+    at: Required[builtins.str]
+    reason_code: Required[Literal['review_passed', 'review_failure', 'processing_failure', 'seller_rereview', 'policy_revocation', 'content_drift', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_deleted', 'takedown_request', 'advertiser_request', 'seller_archive', 'account_closed', 'account_suspended', 'retention_expired', 'legal_erasure']]
+
+class _ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ListCreativesResponseCreativesItemVariant2Assignments(TypedDict, total=False):
+    assignment_count: Required[builtins.int]
+    assigned_packages: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant2AssignmentsAssignedPackagesItem]]
+
+class _ListCreativesResponseCreativesItemVariant2Snapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.int]
+    last_served: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2ItemsItemVariant1(TypedDict, total=False):
+    asset_kind: Required[Literal['media']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content_uri: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2ItemsItemVariant2(TypedDict, total=False):
+    asset_kind: Required[Literal['text']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content: Required[builtins.str | builtins.list[builtins.str]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2Purge(TypedDict, total=False):
+    kind: Required[Literal['soft']]
+    at: Required[builtins.str]
+    reason_code: Required[Literal['review_passed', 'review_failure', 'processing_failure', 'seller_rereview', 'policy_revocation', 'content_drift', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_deleted', 'takedown_request', 'advertiser_request', 'seller_archive', 'account_closed', 'account_suspended', 'retention_expired', 'legal_erasure']]
+
+class _ListTasksResponseQuerySummaryDomainBreakdown(TypedDict, total=False):
+    signals: NotRequired[builtins.int]
+    creative: NotRequired[builtins.int]
+
+class _ListTasksResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: Required[builtins.str]
+    direction: Required[Literal['asc', 'desc']]
+
+class _ExternalCoreTransformerVoiceSynthesisRefItem(TypedDict, total=False):
+    brand_agent: Required[_ExternalCoreTransformerVoiceSynthesisRefItemBrandAgent]
+    voice_id: Required[builtins.str]
+    rights_id: NotRequired[builtins.str]
+
+class _ExternalCoreTransformerParam(TypedDict, total=False):
+    field: Required[builtins.str]
+    type: Required[Literal['string', 'number', 'integer', 'boolean']]
+    value_source: Required[Literal['inline', 'range', 'enumerable', 'free_text']]
+    max_length: NotRequired[builtins.int]
+    allowed_values: NotRequired[builtins.list[Any]]
+    minimum: NotRequired[builtins.float]
+    maximum: NotRequired[builtins.float]
+    options: NotRequired[builtins.list[_ExternalCoreTransformerParamOptionsItem]]
+    options_cursor: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    required: NotRequired[builtins.bool]
+    description: NotRequired[builtins.str]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreTransformerPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerMultiplicity(TypedDict, total=False):
+    supports_catalog_fanout: NotRequired[builtins.bool]
+    max_creatives_limit: NotRequired[builtins.int]
+    supports_variants: NotRequired[builtins.bool]
+    max_variants_limit: NotRequired[builtins.int]
+    variant_dimensions: NotRequired[builtins.list[Literal['voice', 'theme', 'best_of_n', 'transformer_config', 'custom']]]
+
+class _ExternalCoreUserMatch(TypedDict, total=False):
+    uids: NotRequired[builtins.list[_ExternalCoreUserMatchUidsItem]]
+    hashed_email: NotRequired[builtins.str]
+    hashed_phone: NotRequired[builtins.str]
+    click_id: NotRequired[builtins.str]
+    click_id_type: NotRequired[builtins.str]
+    client_ip: NotRequired[builtins.str]
+    client_user_agent: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreEventCustomData(TypedDict, total=False):
+    value: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    order_id: NotRequired[builtins.str]
+    content_ids: NotRequired[builtins.list[builtins.str]]
+    content_type: NotRequired[builtins.str]
+    content_name: NotRequired[builtins.str]
+    content_category: NotRequired[builtins.str]
+    num_items: NotRequired[builtins.int]
+    search_string: NotRequired[builtins.str]
+    progress_percent: NotRequired[builtins.float]
+    progress_seconds: NotRequired[builtins.float]
+    contents: NotRequired[builtins.list[_ExternalCoreEventCustomDataContentsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreEventSurface(TypedDict, total=False):
+    category: Required[Literal['owned_property', 'website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    property_type: NotRequired[builtins.str]
+    namespace: NotRequired[builtins.str]
+    property_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_PackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _PackageRequestOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreTargetingGeoMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoMetrosExcludeItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreDaypartTarget(TypedDict, total=False):
+    days: Required[builtins.list[Literal['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']]]
+    start_hour: Required[builtins.int]
+    end_hour: Required[builtins.int]
+    label: NotRequired[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroups(TypedDict, total=False):
+    operator: Required[Literal['all']]
+    groups: Required[builtins.list[_ExternalCorePackageSignalTargetingGroup]]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalCoreCollectionListRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _ExternalCoreTargetingAgeRestriction(TypedDict, total=False):
+    min: Required[builtins.int]
+    verification_required: NotRequired[builtins.bool]
+    accepted_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _ExternalCoreTargetingStoreCatchmentsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    store_ids: NotRequired[builtins.list[builtins.str]]
+    catchment_ids: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_ExternalCoreTargetingGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant1Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_ExternalCoreTargetingGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant2Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant3Radius]
+    geometry: Required[_ExternalCoreTargetingGeoProximityItemVariant3Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingKeywordTargetsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalCoreTargetingNegativeKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _ExternalCoreMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _PackageRequestCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCorePlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _PackageRequestCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PackageRequestCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PackageRequestCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PackageRequestCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PackageRequestCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PackageRequestCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant1 | _PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant1 | _PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestRequestsItemInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1Response(TypedDict, total=False):
+    previews: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2Response(TypedDict, total=False):
+    previews: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1Embedding]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant2Embedding]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeResponseManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeResponseManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeResponseManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ReportPlanOutcomeRequestSellerResponsePackagesItem(TypedDict, total=False):
+    budget: NotRequired[builtins.float]
+
+class _ReportPlanOutcomeRequestDeliveryReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ReportUsageRequestUsageItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ReportUsageRequestUsageItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SearchBrandResultHouse(TypedDict, total=False):
+    domain: Required[builtins.str]
+    name: Required[builtins.str]
+
+class _SearchBrandResultLogosItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    orientation: NotRequired[Literal['square', 'horizontal', 'vertical', 'stacked']]
+    background: NotRequired[Literal['dark-bg', 'light-bg', 'transparent-bg']]
+    variant: NotRequired[Literal['primary', 'secondary', 'icon', 'wordmark', 'full-lockup']]
+
+class _SearchBrandResultRights(TypedDict, total=False):
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipal(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    account: NotRequired[_ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipalAccount]
+    operator: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligation(TypedDict, total=False):
+    required: Required[builtins.bool]
+    label_text: NotRequired[builtins.str]
+    timing: NotRequired[Literal['before_use', 'at_first_influenced_output', 'near_each_influenced_output']]
+    proximity: NotRequired[Literal['session_level', 'near_rendered_unit', 'near_influenced_output']]
+    jurisdictions: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligationJurisdictionsItem]]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['brand_agent', 'seller', 'network', 'platform']]
+
+class _ExternalSponsoredIntelligenceSiIdentityPrivacyPolicyAcknowledged(TypedDict, total=False):
+    brand_policy_url: NotRequired[builtins.str]
+    brand_policy_version: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentityUser(TypedDict, total=False):
+    email: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    locale: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+    shipping_address: NotRequired[_ExternalSponsoredIntelligenceSiIdentityUserShippingAddress]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalities(TypedDict, total=False):
+    conversational: NotRequired[builtins.bool]
+    voice: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVoiceVariant2]
+    video: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVideoVariant2]
+    avatar: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesAvatarVariant2]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesComponents(TypedDict, total=False):
+    standard: NotRequired[builtins.list[Literal['text', 'link', 'image', 'product_card', 'carousel', 'action_button']]]
+    extensions: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesCommerce(TypedDict, total=False):
+    acp_checkout: NotRequired[builtins.bool]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesA2ui(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    catalogs: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceipt(TypedDict, total=False):
+    status: Required[Literal['accepted', 'rejected']]
+    accepted_context_use: NotRequired[Literal['presentation_only', 'comparison_set', 'reasoning_context']]
+    received_at: Required[builtins.str]
+    host_surface: NotRequired[builtins.str]
+    disclosure_commitment: NotRequired[_ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceiptDisclosureCommitment]
+    rejection_reason: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiUiElement(TypedDict, total=False):
+    type: Required[Literal['text', 'link', 'image', 'product_card', 'carousel', 'action_button', 'app_handoff', 'integration_actions']]
+    data: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalA2uiSurface(TypedDict, total=False):
+    surfaceId: Required[builtins.str]
+    catalogId: NotRequired[builtins.str]
+    components: Required[builtins.list[_ExternalA2uiComponent]]
+    rootId: NotRequired[builtins.str]
+    dataModel: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiSendMessageResponseHandoffIntent(TypedDict, total=False):
+    action: NotRequired[builtins.str]
+    product: NotRequired[builtins.dict[builtins.str, Any]]
+    price: NotRequired[_SiSendMessageResponseHandoffIntentPrice]
+
+class _SiSendMessageResponseHandoffContextForCheckout(TypedDict, total=False):
+    conversation_summary: NotRequired[builtins.str]
+    applied_offers: NotRequired[builtins.list[builtins.str]]
+
+class _SiTerminateSessionRequestTerminationContextTransactionIntent(TypedDict, total=False):
+    action: NotRequired[Literal['purchase', 'subscribe']]
+    product: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsRequestAccountsItemVariant1AccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant1AccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAccountsRequestAccountsItemVariant1NotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['scheduled', 'final', 'delayed', 'adjusted', 'impairment', 'creative.status_changed', 'creative.purged', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    authentication: NotRequired[_SyncAccountsRequestAccountsItemVariant1NotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsRequestAccountsItemVariant2AccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant2AccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAccountsRequestAccountsItemVariant2NotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['scheduled', 'final', 'delayed', 'adjusted', 'impairment', 'creative.status_changed', 'creative.purged', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    authentication: NotRequired[_SyncAccountsRequestAccountsItemVariant2NotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsResponseAccountsItemSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _SyncAccountsResponseAccountsItemCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAudienceMember(TypedDict, total=False):
+    external_id: Required[builtins.str]
+    hashed_email: NotRequired[builtins.str]
+    hashed_phone: NotRequired[builtins.str]
+    uids: NotRequired[builtins.list[_ExternalCoreAudienceMemberUidsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAudiencesResponseAudiencesItemMatchBreakdownItem(TypedDict, total=False):
+    id_type: Required[Literal['hashed_email', 'hashed_phone', 'rampid', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'other']]
+    submitted: Required[builtins.int]
+    matched: Required[builtins.int]
+    match_rate: Required[builtins.float]
+
+class _SyncCatalogsResponseCatalogsItemItemIssuesItem(TypedDict, total=False):
+    item_id: Required[builtins.str]
+    status: Required[Literal['approved', 'pending', 'rejected', 'warning', 'withdrawn']]
+    reasons: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _SyncCreativesRequestCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _SyncCreativesRequestCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _SyncEventSourcesResponseEventSourcesItemSetup(TypedDict, total=False):
+    snippet: NotRequired[builtins.str]
+    snippet_type: NotRequired[Literal['javascript', 'html', 'pixel_url', 'server_only']]
+    instructions: NotRequired[builtins.str]
+
+class _ExternalCoreEventSourceHealth(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    detail: NotRequired[_ExternalCoreEventSourceHealthDetail]
+    match_rate: NotRequired[builtins.float]
+    last_event_at: NotRequired[builtins.str]
+    evaluated_at: NotRequired[builtins.str]
+    events_received_24h: NotRequired[builtins.int]
+    issues: NotRequired[builtins.list[_ExternalCoreDiagnosticIssue]]
+
+class _SyncGovernanceRequestAccountsItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncGovernanceRequestAccountsItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncGovernanceRequestAccountsItemGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    authentication: Required[_SyncGovernanceRequestAccountsItemGovernanceAgentsItemAuthentication]
+
+class _SyncGovernanceResponseAccountsItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncGovernanceResponseAccountsItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncGovernanceResponseAccountsItemGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemBudgetVariant1(TypedDict, total=False):
+    total: Required[builtins.float]
+    currency: Required[builtins.str]
+    per_seller_max_pct: NotRequired[builtins.float]
+    reallocation_threshold: Required[builtins.float]
+    reallocation_unlimited: NotRequired[builtins.bool]
+    allocations: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemBudgetVariant1AllocationsValue]]
+
+class _SyncPlansRequestPlansItemBudgetVariant2(TypedDict, total=False):
+    total: Required[builtins.float]
+    currency: Required[builtins.str]
+    per_seller_max_pct: NotRequired[builtins.float]
+    reallocation_threshold: NotRequired[builtins.float]
+    reallocation_unlimited: Required[Literal[True]]
+    allocations: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemBudgetVariant2AllocationsValue]]
+
+class _SyncPlansRequestPlansItemChannels(TypedDict, total=False):
+    required: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    allowed: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    mix_targets: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemChannelsMixTargetsValue]]
+
+class _SyncPlansRequestPlansItemFlight(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraints(TypedDict, total=False):
+    include: NotRequired[builtins.list[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant4]]
+    exclude: NotRequired[builtins.list[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant4]]
+
+class _SyncPlansRequestPlansItemDelegationsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    authority: Required[Literal['full', 'execute_only', 'propose_only']]
+    budget_limit: NotRequired[_SyncPlansRequestPlansItemDelegationsItemBudgetLimit]
+    markets: NotRequired[builtins.list[builtins.str]]
+    expires_at: NotRequired[builtins.str]
+
+class _SyncPlansRequestPlansItemPortfolio(TypedDict, total=False):
+    member_plan_ids: Required[builtins.list[builtins.str]]
+    total_budget_cap: NotRequired[_SyncPlansRequestPlansItemPortfolioTotalBudgetCap]
+    shared_policy_ids: NotRequired[builtins.list[builtins.str]]
+    shared_exclusions: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+
+class _SyncPlansResponsePlansItemCategoriesItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    status: Required[Literal['active', 'inactive']]
+
+class _SyncPlansResponsePlansItemResolvedPoliciesItem(TypedDict, total=False):
+    policy_id: Required[builtins.str]
+    source: Required[Literal['explicit', 'auto_applied']]
+    enforcement: Required[Literal['must', 'should', 'may']]
+    reason: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetRequestAccountVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverride]
+
+class _TasksGetResponseAdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseAdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponsePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseErrorDetails(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    operation: NotRequired[builtins.str]
+    specific_context: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant1AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant1PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant1ProductsItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    publisher_properties: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPublisherPropertiesItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPublisherPropertiesItemVariant2 | _TasksGetResponseResultVariant1ProductsItemPublisherPropertiesItemVariant3]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatIdsItem]]
+    format_options: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant13]]
+    placements: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItem]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    delivery_type: Required[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    pricing_options: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9]]
+    forecast: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecast]
+    outcome_measurement: NotRequired[_TasksGetResponseResultVariant1ProductsItemOutcomeMeasurement]
+    delivery_measurement: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurement]
+    measurement_terms: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItem]]
+    cancellation_policy: NotRequired[_TasksGetResponseResultVariant1ProductsItemCancellationPolicy]
+    allowed_actions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemAllowedActionsItem]]
+    reporting_capabilities: Required[_TasksGetResponseResultVariant1ProductsItemReportingCapabilities]
+    creative_policy: NotRequired[_TasksGetResponseResultVariant1ProductsItemCreativePolicy]
+    is_custom: NotRequired[builtins.bool]
+    property_targeting_allowed: NotRequired[builtins.bool]
+    data_provider_signals: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemDataProviderSignalsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemDataProviderSignalsItemVariant2 | _TasksGetResponseResultVariant1ProductsItemDataProviderSignalsItemVariant3]]
+    included_signals: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemIncludedSignalsItem]]
+    signal_targeting_options: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItem]]
+    signal_targeting_rules: NotRequired[_TasksGetResponseResultVariant1ProductsItemSignalTargetingRules]
+    signal_targeting_allowed: NotRequired[builtins.bool]
+    catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    metric_optimization: NotRequired[_TasksGetResponseResultVariant1ProductsItemMetricOptimization]
+    vendor_metric_optimization: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimization]
+    max_optimization_goals: NotRequired[builtins.int]
+    measurement_readiness: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementReadiness]
+    conversion_tracking: NotRequired[_TasksGetResponseResultVariant1ProductsItemConversionTracking]
+    catalog_match: NotRequired[_TasksGetResponseResultVariant1ProductsItemCatalogMatch]
+    brief_relevance: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    product_card: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCard]
+    product_card_detailed: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailed]
+    collections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemCollectionsItem]]
+    collection_targeting_allowed: NotRequired[builtins.bool]
+    installments: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemInstallmentsItem]]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_TasksGetResponseResultVariant1ProductsItemTrustedMatch]
+    material_submission: NotRequired[_TasksGetResponseResultVariant1ProductsItemMaterialSubmission]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItem(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    allocations: Required[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItem]]
+    proposal_status: NotRequired[Literal['draft', 'committed']]
+    expires_at: NotRequired[builtins.str]
+    insertion_order: NotRequired[_TasksGetResponseResultVariant1ProposalsItemInsertionOrder]
+    total_budget_guidance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemTotalBudgetGuidance]
+    brief_alignment: NotRequired[builtins.str]
+    forecast: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant1ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1RefinementAppliedItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1RefinementAppliedItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1RefinementAppliedItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1IncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['products', 'pricing', 'forecast', 'proposals', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_TasksGetResponseResultVariant1IncompleteItemEstimatedWait]
+
+class _TasksGetResponseResultVariant1FilterDiagnostics(TypedDict, total=False):
+    semantics: NotRequired[Literal['only', 'any', 'approximate']]
+    total_candidates: NotRequired[builtins.int]
+    excluded_by: NotRequired[builtins.dict[builtins.str, _TasksGetResponseResultVariant1FilterDiagnosticsExcludedByValue]]
+
+class _TasksGetResponseResultVariant1Pagination(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    publisher_properties: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPublisherPropertiesItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPublisherPropertiesItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemPublisherPropertiesItemVariant3]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatIdsItem]]
+    format_options: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant13]]
+    placements: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItem]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    delivery_type: Required[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    pricing_options: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9]]
+    forecast: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecast]
+    outcome_measurement: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemOutcomeMeasurement]
+    delivery_measurement: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurement]
+    measurement_terms: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItem]]
+    cancellation_policy: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemCancellationPolicy]
+    allowed_actions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemAllowedActionsItem]]
+    reporting_capabilities: Required[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilities]
+    creative_policy: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemCreativePolicy]
+    is_custom: NotRequired[builtins.bool]
+    property_targeting_allowed: NotRequired[builtins.bool]
+    data_provider_signals: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemDataProviderSignalsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemDataProviderSignalsItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemDataProviderSignalsItemVariant3]]
+    included_signals: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItem]]
+    signal_targeting_options: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItem]]
+    signal_targeting_rules: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingRules]
+    signal_targeting_allowed: NotRequired[builtins.bool]
+    catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    metric_optimization: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMetricOptimization]
+    vendor_metric_optimization: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimization]
+    max_optimization_goals: NotRequired[builtins.int]
+    measurement_readiness: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementReadiness]
+    conversion_tracking: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemConversionTracking]
+    catalog_match: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemCatalogMatch]
+    brief_relevance: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    product_card: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCard]
+    product_card_detailed: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailed]
+    collections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemCollectionsItem]]
+    collection_targeting_allowed: NotRequired[builtins.bool]
+    installments: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItem]]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemTrustedMatch]
+    material_submission: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMaterialSubmission]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant4ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant4ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant5AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant5PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant5SignalsItem(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant5SignalsItemSignalRefVariant1 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant2 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant3 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant4 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant5 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant6 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant7 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant8 | _TasksGetResponseResultVariant5SignalsItemSignalRefVariant9]
+    signal_id: NotRequired[_TasksGetResponseResultVariant5SignalsItemSignalIdVariant1 | _TasksGetResponseResultVariant5SignalsItemSignalIdVariant2]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_TasksGetResponseResultVariant5SignalsItemRange]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    taxonomy: NotRequired[_TasksGetResponseResultVariant5SignalsItemTaxonomy]
+    segmentation_criteria: NotRequired[builtins.str]
+    criteria_url: NotRequired[builtins.str]
+    data_sources: NotRequired[builtins.list[Literal['app_behavior', 'app_usage', 'web_usage', 'geo_location', 'email', 'tv_ott_or_stb_device', 'panel', 'online_ecommerce', 'credit_data', 'loyalty_card', 'transaction', 'online_survey', 'offline_survey', 'public_record_census', 'public_record_voter_file', 'public_record_other', 'offline_transaction']]]
+    methodology: NotRequired[Literal['observed', 'declared', 'derived', 'inferred', 'modeled']]
+    audience_expansion: NotRequired[builtins.bool]
+    device_expansion: NotRequired[builtins.bool]
+    refresh_cadence: NotRequired[Literal['intra_day', 'daily', 'weekly', 'monthly', 'bi_monthly', 'quarterly', 'bi_annually', 'annually']]
+    lookback_window: NotRequired[Literal['intra_day', 'daily', 'weekly', 'monthly', 'bi_monthly', 'quarterly', 'bi_annually', 'annually']]
+    onboarder: NotRequired[_TasksGetResponseResultVariant5SignalsItemOnboarder]
+    countries: NotRequired[builtins.list[builtins.str]]
+    consent_basis: NotRequired[builtins.list[Literal['consent', 'legitimate_interest', 'contract', 'legal_obligation']]]
+    art9_basis: NotRequired[Literal['explicit_consent', 'manifestly_made_public', 'substantial_public_interest', 'vital_interests']]
+    modeling: NotRequired[_TasksGetResponseResultVariant5SignalsItemModeling]
+    data_subject_rights: NotRequired[_TasksGetResponseResultVariant5SignalsItemDataSubjectRights]
+    dts_compliant_version: NotRequired[builtins.str]
+    signal_agent_segment_id: Required[builtins.str]
+    signal_type: Required[Literal['marketplace', 'custom', 'owned']]
+    data_provider: NotRequired[builtins.str]
+    coverage_percentage: NotRequired[builtins.float]
+    coverage_forecast: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecast]
+    deployments: Required[builtins.list[_TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant1 | _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant1 | _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant2 | _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant3 | _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant4 | _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant5]]
+
+class _TasksGetResponseResultVariant5ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant5ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5IncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['signals', 'pricing', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_TasksGetResponseResultVariant5IncompleteItemEstimatedWait]
+
+class _TasksGetResponseResultVariant5Pagination(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant7ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant7ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant8Variant1PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant8Variant1Account(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrand]
+    operator: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBillingEntity]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_TasksGetResponseResultVariant8Variant1AccountCreditLimit]
+    setup: NotRequired[_TasksGetResponseResultVariant8Variant1AccountSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_TasksGetResponseResultVariant8Variant1AccountReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountNotificationConfigsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1InvoiceRecipient(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_TasksGetResponseResultVariant8Variant1InvoiceRecipientAddress]
+    contacts: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1InvoiceRecipientContactsItem]]
+    bank: NotRequired[_TasksGetResponseResultVariant8Variant1InvoiceRecipientBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1AvailableActionsItem(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_TasksGetResponseResultVariant8Variant1AvailableActionsItemSla]
+    terms_ref: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPriceBreakdown]
+    impressions: NotRequired[builtins.float]
+    catalogs: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCatalogsItem]]
+    format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemFormatIdsItem]]
+    format_option_refs: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemFormatOptionRefsItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    targeting_overlay: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlay]
+    measurement_terms: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItem]]
+    committed_metrics: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2]]
+    creative_assignments: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCreativeAssignmentsItem]]
+    format_ids_to_provide: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemFormatIdsToProvideItem]]
+    optimization_goals: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCancellation]
+    agency_estimate_number: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDelivery(TypedDict, total=False):
+    geo: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryGeo]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    frequency_cap: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryFrequencyCap]
+    audience_summary: NotRequired[builtins.str]
+    audience_targeting: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant4]]
+    total_budget: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant2AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant2AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant2PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant8Variant2PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant8Variant2ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant2ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant3AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant3AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant3PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant8Variant3PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant8Variant3ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant3ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant10ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant10ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant11ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant11ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant12Variant1PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant12Variant1InvoiceRecipient(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_TasksGetResponseResultVariant12Variant1InvoiceRecipientAddress]
+    contacts: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1InvoiceRecipientContactsItem]]
+    bank: NotRequired[_TasksGetResponseResultVariant12Variant1InvoiceRecipientBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPriceBreakdown]
+    impressions: NotRequired[builtins.float]
+    catalogs: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCatalogsItem]]
+    format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatIdsItem]]
+    format_option_refs: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatOptionRefsItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    targeting_overlay: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlay]
+    measurement_terms: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItem]]
+    committed_metrics: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2]]
+    creative_assignments: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCreativeAssignmentsItem]]
+    format_ids_to_provide: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatIdsToProvideItem]]
+    optimization_goals: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCancellation]
+    agency_estimate_number: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AvailableActionsItem(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_TasksGetResponseResultVariant12Variant1AvailableActionsItemSla]
+    terms_ref: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant2AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant2AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant2PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant12Variant2PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant12Variant2ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant2ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant3AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant3AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant3PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant12Variant3PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant12Variant3ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant3ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant15ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant15ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16ReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _TasksGetResponseResultVariant16AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_TasksGetResponseResultVariant16AttributionWindowPostClick]
+    post_view: NotRequired[_TasksGetResponseResultVariant16AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItem(TypedDict, total=False):
+    media_buy_id: Required[builtins.str]
+    status: Required[Literal['pending_creatives', 'pending_start', 'pending', 'active', 'paused', 'completed', 'rejected', 'canceled', 'failed', 'reporting_delayed']]
+    expected_availability: NotRequired[builtins.str]
+    is_adjusted: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    pricing_model: NotRequired[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    totals: Required[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotals]
+    by_package: Required[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItem]]
+
+class _TasksGetResponseResultVariant16ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant16ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant17Variant1PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1FormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1FormatOptionRefVariant1 | _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1Brand]
+    rights: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1RightsItem]]
+    industry_identifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1IndustryIdentifiersItem]]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1Provenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2FormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2FormatOptionRefVariant1 | _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2Brand]
+    rights: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2RightsItem]]
+    industry_identifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2IndustryIdentifiersItem]]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2Provenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1Preview(TypedDict, total=False):
+    previews: Required[builtins.list[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1PreviewError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1PreviewErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1Consumption(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant17Variant2PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1(TypedDict, total=False):
+    format_id: Required[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1FormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1FormatOptionRefVariant1 | _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1Brand]
+    rights: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1RightsItem]]
+    industry_identifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1IndustryIdentifiersItem]]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1Provenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2(TypedDict, total=False):
+    format_id: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2FormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2FormatOptionRefVariant1 | _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2Brand]
+    rights: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2RightsItem]]
+    industry_identifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2IndustryIdentifiersItem]]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2Provenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2Preview(TypedDict, total=False):
+    previews: Required[builtins.list[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2PreviewError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2PreviewErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2Consumption(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant3AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant17Variant3PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItem(TypedDict, total=False):
+    build_creative_id: NotRequired[builtins.str]
+    catalog_item_ref: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemCatalogItemRef]
+    signal_condition: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3]
+    variants: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItem]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemErrorsItem]]
+
+class _TasksGetResponseResultVariant17Variant3ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant4AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant4AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant4PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant17Variant4PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant17Variant4Estimate(TypedDict, total=False):
+    items_total: NotRequired[builtins.int]
+    items_to_produce: NotRequired[builtins.int]
+    conditions_total: NotRequired[builtins.int]
+    variants_per_item: NotRequired[builtins.int]
+    leaves_total: NotRequired[builtins.int]
+    currency: Required[builtins.str]
+    cost_low: Required[builtins.float]
+    cost_high: Required[builtins.float]
+    cost_expected: NotRequired[builtins.float]
+    basis: Required[Literal['fixed', 'estimated_units', 'cpm_deferred']]
+    per_leaf: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant4EstimatePerLeafItem]]
+
+class _TasksGetResponseResultVariant17Variant5AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant5AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant5PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant17Variant5PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant17Variant5ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant5ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant6AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant6AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant6PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant17Variant6PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant17Variant6ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant6ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant19ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant19ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant20ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant20ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant21Variant1PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccount]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    platform_id: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemErrorsItem]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    preview_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    assigned_to: NotRequired[builtins.list[builtins.str]]
+    assignment_errors: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant2AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant2AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant2PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant21Variant2PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant21Variant2ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant2ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant3AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant3AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant3PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant21Variant3PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant21Variant3ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant3ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant24ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant24ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant1AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant1AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant1PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant25Variant1PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant25Variant1CatalogsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    platform_id: NotRequired[builtins.str]
+    item_count: NotRequired[builtins.int]
+    items_approved: NotRequired[builtins.int]
+    items_pending: NotRequired[builtins.int]
+    items_rejected: NotRequired[builtins.int]
+    item_issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant1CatalogsItemItemIssuesItem]]
+    last_synced_at: NotRequired[builtins.str]
+    next_fetch_at: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant1CatalogsItemErrorsItem]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant25Variant2AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant2AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant2PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant25Variant2PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant25Variant2ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant2ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant3AdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant3AdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant3PushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponseResultVariant25Variant3PushNotificationConfigAuthentication]
+
+class _TasksGetResponseResultVariant25Variant3ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant3ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant28ErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant28ErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksListRequestAccountVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverride]
+
+class _TasksListResponseAdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksListResponseAdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksListResponsePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksListResponseQuerySummaryDomainBreakdown(TypedDict, total=False):
+    signals: NotRequired[builtins.int]
+    creative: NotRequired[builtins.int]
+
+class _TasksListResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: Required[builtins.str]
+    direction: Required[Literal['asc', 'desc']]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant1(TypedDict, total=False):
+    type: Required[Literal['url']]
+    value: Required[builtins.str]
+    language: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4]]
+    metadata: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant2 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateKeywordTargetsAddItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateKeywordTargetsRemoveItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateNegativeKeywordsAddItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateNegativeKeywordsRemoveItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant1 | _ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant1 | _ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ValidateContentDeliveryRequestRecordsItemBrandContext(TypedDict, total=False):
+    brand_id: NotRequired[builtins.str]
+    sku_id: NotRequired[builtins.str]
+
+class _ValidateContentDeliveryResponseResultsItemFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ValidateInputRequestManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ValidateInputRequestManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ValidateInputRequestManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ValidateInputRequestManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCreativeValidateInputResultTarget(TypedDict, total=False):
+    kind: Required[Literal['canonical', 'product', 'third_party_format']]
+    id: Required[builtins.str]
+
+class _ExternalCreativeValidateInputResultViolationsItem(TypedDict, total=False):
+    rule: Required[builtins.str]
+    expected: NotRequired[Any]
+    predicted: NotRequired[Any]
+    field: Required[builtins.str]
+    retry_with: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyValidationResultFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    requirement: NotRequired[_ExternalPropertyValidationResultFeaturesItemRequirement]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalPropertyAuthorizationResult(TypedDict, total=False):
+    status: Required[Literal['authorized', 'unauthorized', 'unknown']]
+    publisher_domain: NotRequired[builtins.str]
+    sales_agent_url: NotRequired[builtins.str]
+    violation: NotRequired[_ExternalPropertyAuthorizationResultViolation]
+
+class _VerifyBrandClaimRequestClaim3Property(TypedDict, total=False):
+    type: Required[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'streaming_audio']]
+    identifier: Required[builtins.str]
+    store: NotRequired[Literal['apple', 'google', 'amazon', 'roku', 'fire_tv', 'samsung', 'lg', 'vizio', 'other']]
+    region: NotRequired[builtins.str]
+
+class _SignedResponsePayload(TypedDict, total=False):
+    typ: Required[Literal['adcp-response-payload+jws']]
+    task: Required[Literal['verify_brand_claim']]
+    brand_domain: Required[builtins.str]
+    agent_url: Required[builtins.str]
+    request_hash: Required[builtins.str]
+    iat: Required[builtins.int]
+    exp: Required[builtins.int]
+    response: Required[_SignedResponsePayloadResponse]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant1Claim(TypedDict, total=False):
+    subsidiary_domain: Required[builtins.str]
+    subsidiary_brand_id: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant2Claim(TypedDict, total=False):
+    parent_domain: Required[builtins.str]
+    claimant_says: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant3Claim(TypedDict, total=False):
+    property: Required[_VerifyBrandClaimsRequestClaimsItemVariant3ClaimProperty]
+    use_case: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant4Claim(TypedDict, total=False):
+    mark: Required[builtins.str]
+    registry: NotRequired[builtins.str]
+    number: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    use_case: NotRequired[builtins.str]
+
+class _SignedResponse2Payload(TypedDict, total=False):
+    typ: Required[Literal['adcp-response-payload+jws']]
+    task: Required[Literal['verify_brand_claims']]
+    brand_domain: Required[builtins.str]
+    agent_url: Required[builtins.str]
+    request_hash: Required[builtins.str]
+    iat: Required[builtins.int]
+    exp: Required[builtins.int]
+    response: Required[_SignedResponse2PayloadResponse]
+
+class _ExternalCoreAssetsImageAsset(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalCoreBrandRefBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _ExternalCoreErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _ExternalCoreProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _ExternalCoreProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _ExternalCoreProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_ExternalCoreProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_ExternalCoreProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_ExternalCoreProvenanceDisclosureJurisdictionsItem]]
+
+class _ExternalCoreProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant1 | _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant1 | _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativesItemVariantsItemEval(TypedDict, total=False):
+    features: NotRequired[builtins.list[_ExternalCreativeCreativeFeatureResult]]
+    ranked_against: NotRequired[builtins.int]
+    calls_used: NotRequired[builtins.int]
+    seconds_used: NotRequired[builtins.float]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalCoreFrequencyCapSuppress(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreFrequencyCapWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ComplyTestControllerRequestParamsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCreativeAuditObservationDetailsClaimedValue(TypedDict, total=False):
+    human_oversight: Required[Literal['edited', 'directed']]
+    disclosure_required: Required[Literal[False]]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _Exemplar(TypedDict, total=False):
+    scenario: Required[builtins.str]
+    explanation: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalCoreNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _ExternalCorePackageCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTrustedMatch(TypedDict, total=False):
+    surfaces: NotRequired[builtins.list[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionCreativeSpecs(TypedDict, total=False):
+    vast_versions: NotRequired[builtins.list[builtins.str]]
+    mraid_versions: NotRequired[builtins.list[builtins.str]]
+    vpaid: NotRequired[builtins.bool]
+    simid: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargeting(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.bool]
+    geo_regions: NotRequired[builtins.bool]
+    geo_metros: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoMetros]
+    geo_postal_areas: NotRequired[_ExternalCorePostalAreaSupport]
+    age_restriction: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingAgeRestriction]
+    language: NotRequired[builtins.bool]
+    keyword_targets: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingKeywordTargets]
+    negative_keywords: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingNegativeKeywords]
+    geo_proximity: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoProximity]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceTargetingMatchingLatencyHours(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+
+class _GetAdcpCapabilitiesResponseMediaBuyConversionTrackingAttributionWindowsItem(TypedDict, total=False):
+    event_type: NotRequired[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    post_click: Required[builtins.list[_ExternalCoreDuration]]
+    post_view: NotRequired[builtins.list[_ExternalCoreDuration]]
+
+class _GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpointTransportsItem(TypedDict, total=False):
+    type: Required[Literal['mcp', 'a2a']]
+    url: Required[builtins.str]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _GetAdcpCapabilitiesResponseMeasurementMetricsItemAccreditationsItem(TypedDict, total=False):
+    accrediting_body: Required[builtins.str]
+    certification_id: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    evidence_url: NotRequired[builtins.str]
+
+class _FontRoleVariant2FilesItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    weight: NotRequired[builtins.int]
+    weight_range: NotRequired[builtins.list[builtins.int]]
+    style: NotRequired[Literal['normal', 'italic', 'oblique']]
+
+class _ExternalCoreDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreVendorMetricValue(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    value: Required[builtins.float]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[builtins.float]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeVariantByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreCreativeVariantReachWindowPeriod]
+
+class _ExternalCoreCreativeVariantQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCreativeVariantDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCreativeVariantViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCreativeVariantByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant1 | _ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeVariantManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant1 | _ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeVariantGenerationContext(TypedDict, total=False):
+    context_type: NotRequired[builtins.str]
+    artifact: NotRequired[_ExternalCoreCreativeVariantGenerationContextArtifact]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1Qualifier]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreCatalogItemDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsQuartileData | _ExternalCoreCatalogItemDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    content_id: Required[builtins.str]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+
+class _ExternalCoreCreativeDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreCreativeDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCreativeDeliveryMetricsQuartileData | _ExternalCoreCreativeDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreCreativeDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCreativeDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreKeywordDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreKeywordDeliveryMetricsQuartileData | _ExternalCoreKeywordDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreKeywordDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreKeywordDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreGeoDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreGeoDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreGeoDeliveryMetricsQuartileData | _ExternalCoreGeoDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreGeoDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreGeoDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    placement_id: Required[builtins.str]
+    placement_name: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDailyBreakdownItem(TypedDict, total=False):
+    date: Required[builtins.str]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotals(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    package_id: Required[builtins.str]
+
+class _ExternalCoreImpairmentTransition(TypedDict, total=False):
+    to: Required[Literal['suspended', 'rejected', 'withdrawn', 'insufficient', 'depublished']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemCreativeApprovalsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    approval_status: Required[Literal['pending_review', 'approved', 'rejected']]
+    rejection_reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemSnapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    currency: NotRequired[builtins.str]
+    clicks: NotRequired[builtins.float]
+    pacing_index: NotRequired[builtins.float]
+    delivery_status: NotRequired[Literal['delivering', 'not_delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryStatuses(TypedDict, total=False):
+    approved: NotRequired[builtins.int]
+    denied: NotRequired[builtins.int]
+    conditions: NotRequired[builtins.int]
+    human_reviewed: NotRequired[builtins.int]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryEscalationsItem(TypedDict, total=False):
+    check_id: Required[builtins.str]
+    reason: Required[builtins.str]
+    resolution: NotRequired[builtins.str]
+    resolved_at: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryDriftMetrics(TypedDict, total=False):
+    escalation_rate: NotRequired[builtins.float]
+    escalation_rate_trend: NotRequired[Literal['increasing', 'stable', 'declining']]
+    auto_approval_rate: NotRequired[builtins.float]
+    human_override_rate: NotRequired[builtins.float]
+    mean_confidence: NotRequired[builtins.float]
+    thresholds: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryDriftMetricsThresholds]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    policy_id: NotRequired[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalCorePlatformExtensionRef(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalImageCarousel(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalImageCarouselSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    card_aspect_ratio: NotRequired[builtins.str]
+    min_cards: NotRequired[builtins.int]
+    max_cards: NotRequired[builtins.int]
+    allowed_card_media_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    allowed_card_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    card_image_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_duration_ms: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    card_headline_max_chars: NotRequired[builtins.int]
+    card_description_max_chars: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalVideoHosted(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalVideoHostedSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    min_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    video_codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'mp3', 'opus', 'pcm']]]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    max_file_size_mb: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    captions: NotRequired[Literal['required', 'recommended', 'not_required']]
+    om_sdk_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    companion_banner_widths: NotRequired[builtins.list[builtins.int]]
+    companion_banner_heights: NotRequired[builtins.list[builtins.int]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalFormatsCanonicalVideoVast(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalVideoVastSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+    vpaid_enabled: NotRequired[builtins.bool]
+    vpaid_version: NotRequired[Literal['1.0', '2.0']]
+    simid_supported: NotRequired[builtins.bool]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    skippable_after_ms: NotRequired[builtins.int]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAudioHosted(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalAudioHostedSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    audio_codecs: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'opus', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+    companion_image_required: NotRequired[builtins.bool]
+    companion_image_aspect_ratio: NotRequired[builtins.str]
+    companion_image_max_file_size_kb: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+
+class _ExternalFormatsCanonicalAudioDaast(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalAudioDaastSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    daast_version: NotRequired[Literal['1.0', '1.1']]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+    companion_image_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalSponsoredPlacement(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalSponsoredPlacementSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    supported_catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    fanout_mode: NotRequired[Literal['per_item', 'multi_item_in_creative', 'single_item']]
+    required_catalog_fields: NotRequired[builtins.list[builtins.str]]
+    supported_id_types: NotRequired[builtins.list[Literal['asin', 'sku', 'gtin', 'offering_id', 'store_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'program_id', 'destination_id', 'app_id', 'job_id']]]
+    hero_asset_supported: NotRequired[builtins.bool]
+    item_production_model: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized']]
+
+class _ExternalFormatsCanonicalNativeInFeed(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalNativeInFeedSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    title_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    main_image_sizes: NotRequired[builtins.list[_ExternalFormatsCanonicalNativeInFeedMainImageSizesItem]]
+    icon_size: NotRequired[_ExternalFormatsCanonicalNativeInFeedIconSize]
+    max_image_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp']]]
+    ssl_required: NotRequired[builtins.bool]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalFormatsCanonicalResponsiveCreative(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalResponsiveCreativeSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    headlines_min: NotRequired[builtins.int]
+    headlines_max: NotRequired[builtins.int]
+    headline_max_chars: NotRequired[builtins.int]
+    long_headlines_min: NotRequired[builtins.int]
+    long_headlines_max: NotRequired[builtins.int]
+    long_headline_max_chars: NotRequired[builtins.int]
+    descriptions_min: NotRequired[builtins.int]
+    descriptions_max: NotRequired[builtins.int]
+    description_max_chars: NotRequired[builtins.int]
+    images_landscape_min: NotRequired[builtins.int]
+    images_landscape_max: NotRequired[builtins.int]
+    images_landscape_aspect_ratio: NotRequired[builtins.str]
+    images_square_min: NotRequired[builtins.int]
+    images_square_max: NotRequired[builtins.int]
+    images_vertical_min: NotRequired[builtins.int]
+    images_vertical_max: NotRequired[builtins.int]
+    videos_min: NotRequired[builtins.int]
+    videos_max: NotRequired[builtins.int]
+    video_min_duration_ms: NotRequired[builtins.int]
+    video_max_duration_ms: NotRequired[builtins.int]
+    logo_min: NotRequired[builtins.int]
+    logo_max: NotRequired[builtins.int]
+    logo_aspect_ratios: NotRequired[builtins.list[builtins.str]]
+    business_name_max_chars: NotRequired[builtins.int]
+    asset_image_max_file_size_kb: NotRequired[builtins.int]
+    supports_catalog_input: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAgentPlacement(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalAgentPlacementSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    output_modality: NotRequired[Literal['text', 'audio', 'card']]
+    max_mention_length_chars: NotRequired[builtins.int]
+    max_mention_duration_ms: NotRequired[builtins.int]
+    supports_offering_reference: NotRequired[builtins.bool]
+    supports_landing_page_url: NotRequired[builtins.bool]
+    tone_constraints: NotRequired[builtins.list[builtins.str]]
+    disclosure_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1 | _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2 | _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3 | _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1 | _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2 | _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3 | _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1 | _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2 | _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3 | _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4]
+
+class _ExternalCorePlacementFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCorePlacementFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCorePlacementFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCorePlacementFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCorePlacementFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCorePlacementFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCorePlacementFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCorePlacementFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCorePlacementFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCorePlacementFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalPricingOptionsPriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _ExternalCoreProductPricingOptionsItemVariant5Parameters(TypedDict, total=False):
+    view_threshold: Required[builtins.float | _ExternalCoreProductPricingOptionsItemVariant5ParametersViewThresholdVariant2]
+
+class _ExternalCoreProductPricingOptionsItemVariant6Parameters(TypedDict, total=False):
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: Required[builtins.str]
+    min_points: NotRequired[builtins.float]
+
+class _ExternalCoreProductPricingOptionsItemVariant8Parameters(TypedDict, total=False):
+    type: Required[Literal['dooh']]
+    sov_percentage: NotRequired[builtins.float]
+    loop_duration_seconds: NotRequired[builtins.int]
+    min_plays_per_hour: NotRequired[builtins.int]
+    venue_package: NotRequired[builtins.str]
+    duration_hours: NotRequired[builtins.float]
+    daypart: NotRequired[builtins.str]
+    estimated_impressions: NotRequired[builtins.int]
+
+class _ExternalCoreProductPricingOptionsItemVariant9Parameters(TypedDict, total=False):
+    time_unit: Required[Literal['hour', 'day', 'week', 'month']]
+    min_duration: NotRequired[builtins.int]
+    max_duration: NotRequired[builtins.int]
+
+class _ExternalCoreForecastPoint(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_ExternalCoreForecastPointDimensionsItemVariant1 | _ExternalCoreForecastPointDimensionsItemVariant2 | _ExternalCoreForecastPointDimensionsItemVariant3 | _ExternalCoreForecastPointDimensionsItemVariant4 | _ExternalCoreForecastPointDimensionsItemVariant5 | _ExternalCoreForecastPointDimensionsItemVariant6]]
+    metrics: Required[_ExternalCoreForecastPointMetrics]
+    viewability: NotRequired[_ExternalCoreForecastPointViewability]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreForecastVendorMetricValue]]
+
+class _ExternalCoreOutcomeMeasurementWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreDuration(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCancellationPolicyCancellationFee(TypedDict, total=False):
+    type: Required[Literal['percent_remaining', 'full_commitment', 'fixed_fee', 'none']]
+    rate: NotRequired[builtins.float]
+    amount: NotRequired[builtins.float]
+
+class _ExternalCoreReportingCapabilitiesVendorMetricsItem(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreGeoBreakdownSupport(TypedDict, total=False):
+    country: NotRequired[builtins.bool]
+    region: NotRequired[builtins.bool]
+    metro: NotRequired[builtins.dict[builtins.str, builtins.bool]]
+    postal_area: NotRequired[_ExternalCorePostalAreaSupport]
+
+class _ExternalCoreMeasurementWindow(TypedDict, total=False):
+    window_id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    duration_days: Required[builtins.int]
+    expected_availability_days: NotRequired[builtins.int]
+    is_guarantee_basis: NotRequired[builtins.bool]
+
+class _ExternalCoreCreativePolicyProvenanceRequirements(TypedDict, total=False):
+    require_digital_source_type: NotRequired[builtins.bool]
+    require_disclosure_metadata: NotRequired[builtins.bool]
+    require_embedded_provenance: NotRequired[builtins.bool]
+
+class _ExternalCoreCreativePolicyAcceptedVerifiersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+    providers: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreSignalListingSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreSignalListingRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _ExternalCoreProductSignalTargetingOptionSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreSignalSelectionGroupRule(TypedDict, total=False):
+    selection_group: Required[builtins.str]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+
+class _ExternalCoreVendorMetricOptimizationSupportedMetric(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _ExternalCoreDiagnosticIssue(TypedDict, total=False):
+    severity: Required[Literal['error', 'warning', 'info']]
+    message: Required[builtins.str]
+
+class _ExternalCoreProductProductCardDetailedSpecificationsItem(TypedDict, total=False):
+    label: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCoreSpecial(TypedDict, total=False):
+    name: Required[builtins.str]
+    category: NotRequired[Literal['awards', 'championship', 'concert', 'conference', 'election', 'festival', 'gala', 'holiday', 'premiere', 'product_launch', 'reunion', 'tribute']]
+    starts: NotRequired[builtins.str]
+    ends: NotRequired[builtins.str]
+
+class _ExternalCoreTalent(TypedDict, total=False):
+    role: Required[Literal['host', 'guest', 'creator', 'cast', 'narrator', 'producer', 'correspondent', 'commentator', 'analyst']]
+    name: Required[builtins.str]
+    brand_url: NotRequired[builtins.str]
+
+class _ExternalCoreAdInventoryConfig(TypedDict, total=False):
+    expected_breaks: Required[builtins.int]
+    total_ad_seconds: NotRequired[builtins.int]
+    max_ad_duration_seconds: NotRequired[builtins.int]
+    unplanned_breaks: NotRequired[builtins.bool]
+    supported_formats: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreInstallmentDeadlines(TypedDict, total=False):
+    booking_deadline: NotRequired[builtins.str]
+    cancellation_deadline: NotRequired[builtins.str]
+    material_deadlines: NotRequired[builtins.list[_ExternalCoreMaterialDeadline]]
+
+class _ExternalCoreInstallmentDerivativeOf(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    type: Required[Literal['clip', 'highlight', 'recap', 'trailer', 'bonus']]
+
+class _ExternalCoreProductTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    countries: NotRequired[builtins.list[builtins.str]]
+    uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+
+class _ExternalCoreProductFiltersTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreInsertionOrderTerms(TypedDict, total=False):
+    advertiser: NotRequired[builtins.str]
+    publisher: NotRequired[builtins.str]
+    total_budget: NotRequired[_ExternalCoreInsertionOrderTermsTotalBudget]
+    flight_start: NotRequired[builtins.str]
+    flight_end: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_30', 'net_60', 'net_90', 'prepaid', 'due_on_receipt']]
+
+class _GetSignalsResponseSignalsItemTaxonomyValuesItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    path: NotRequired[builtins.str]
+    modifiers: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsResponseSignalsItemTaxonomyValueMappingsItem(TypedDict, total=False):
+    value: Required[builtins.str]
+    taxonomy_value_id: Required[builtins.str]
+    path: NotRequired[builtins.str]
+    modifiers: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsResponseSignalsItemModelingSeedSource(TypedDict, total=False):
+    type: Required[Literal['first_party_crm', 'panel', 'declared_survey', 'transactional', 'behavioral']]
+    provider_signed: Required[builtins.bool]
+
+class _ExternalCoreSignalModelingDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_ExternalCoreSignalModelingDisclosureJurisdictionsItem]]
+    notes: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemDataSubjectRightsChannelsItem(TypedDict, total=False):
+    rights: Required[builtins.list[Literal['access', 'rectification', 'erasure', 'portability', 'objection']]]
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreSignalCoverageForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: Required[builtins.list[_ExternalCoreForecastPointDimensionsItemVariant1 | _ExternalCoreForecastPointDimensionsItemVariant2 | _ExternalCoreForecastPointDimensionsItemVariant3 | _ExternalCoreForecastPointDimensionsItemVariant4 | _ExternalCoreForecastPointDimensionsItemVariant5 | _ExternalCoreForecastPointDimensionsItemVariant6]]
+    metrics: Required[_ExternalCoreSignalCoverageForecastPointsItemMetrics]
+    viewability: NotRequired[_ExternalCoreSignalCoverageForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreForecastVendorMetricValue]]
+
+class _ExternalCoreSignalCoverageForecastScope(TypedDict, total=False):
+    kind: Required[Literal['inventory', 'product', 'account', 'custom']]
+    label: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    line_item_types: NotRequired[builtins.list[builtins.str]]
+    date_range: NotRequired[_ExternalCoreDateRange]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: NotRequired[builtins.float]
+    height: NotRequired[builtins.float]
+    min_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    responsive: NotRequired[_ExternalCoreFormatRendersItemVariant1DimensionsResponsive]
+    aspect_ratio: NotRequired[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: NotRequired[builtins.float]
+    height: NotRequired[builtins.float]
+    min_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    responsive: NotRequired[_ExternalCoreFormatRendersItemVariant2DimensionsResponsive]
+    aspect_ratio: NotRequired[builtins.str]
+
+class _ExternalCoreOverlay(TypedDict, total=False):
+    id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    visual: NotRequired[_ExternalCoreOverlayVisual]
+    bounds: Required[_ExternalCoreOverlayBounds]
+
+class _ExternalCoreRequirementsImageAssetRequirements(TypedDict, total=False):
+    min_width: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    aspect_ratio: NotRequired[builtins.str]
+    formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'avif', 'tiff', 'pdf', 'eps']]]
+    min_dpi: NotRequired[builtins.int]
+    bleed: NotRequired[_ExternalCoreRequirementsImageAssetRequirementsBleedVariant1 | _ExternalCoreRequirementsImageAssetRequirementsBleedVariant2]
+    color_space: NotRequired[Literal['rgb', 'cmyk', 'grayscale']]
+    max_file_size_kb: NotRequired[builtins.int]
+    transparency_required: NotRequired[builtins.bool]
+    animation_allowed: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_weight_grams: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsVideoAssetRequirements(TypedDict, total=False):
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    min_duration_ms: NotRequired[builtins.int]
+    max_duration_ms: NotRequired[builtins.int]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov', 'avi', 'mkv']]]
+    codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    max_file_size_kb: NotRequired[builtins.int]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    audio_required: NotRequired[builtins.bool]
+    frame_rate_type: NotRequired[Literal['constant', 'variable']]
+    scan_type: NotRequired[Literal['progressive', 'interlaced']]
+    gop_type: NotRequired[Literal['closed', 'open']]
+    min_gop_interval_seconds: NotRequired[builtins.float]
+    max_gop_interval_seconds: NotRequired[builtins.float]
+    moov_atom_position: NotRequired[Literal['start', 'end']]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'pcm', 'ac3', 'eac3', 'mp3', 'opus', 'vorbis', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo', '5.1', '7.1']]]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsAudioAssetRequirements(TypedDict, total=False):
+    min_duration_ms: NotRequired[builtins.int]
+    max_duration_ms: NotRequired[builtins.int]
+    formats: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'ogg', 'flac']]]
+    max_file_size_kb: NotRequired[builtins.int]
+    sample_rates: NotRequired[builtins.list[builtins.int]]
+    channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsTextAssetRequirements(TypedDict, total=False):
+    min_length: NotRequired[builtins.int]
+    max_length: NotRequired[builtins.int]
+    min_lines: NotRequired[builtins.int]
+    max_lines: NotRequired[builtins.int]
+    character_pattern: NotRequired[builtins.str]
+    prohibited_terms: NotRequired[builtins.list[builtins.str]]
+    allowed_values: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsMarkdownAssetRequirements(TypedDict, total=False):
+    max_length: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsHtmlAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+    sandbox: NotRequired[Literal['none', 'iframe', 'safeframe', 'fencedframe']]
+    external_resources_allowed: NotRequired[builtins.bool]
+    allowed_external_domains: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsCssAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsJavascriptAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+    module_type: NotRequired[Literal['script', 'module', 'iife']]
+    strict_mode_required: NotRequired[builtins.bool]
+    external_resources_allowed: NotRequired[builtins.bool]
+    allowed_external_domains: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsVastAssetRequirements(TypedDict, total=False):
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+
+class _ExternalCoreRequirementsDaastAssetRequirements(TypedDict, total=False):
+    daast_version: NotRequired[Literal['1.0']]
+
+class _ExternalCoreRequirementsUrlAssetRequirements(TypedDict, total=False):
+    role: NotRequired[Literal['clickthrough', 'landing_page', 'impression_tracker', 'click_tracker', 'viewability_tracker', 'third_party_tracker']]
+    protocols: NotRequired[builtins.list[Literal['https', 'http']]]
+    allowed_domains: NotRequired[builtins.list[builtins.str]]
+    max_length: NotRequired[builtins.int]
+    macro_support: NotRequired[builtins.bool]
+
+class _ExternalCoreRequirementsWebhookAssetRequirements(TypedDict, total=False):
+    methods: NotRequired[builtins.list[Literal['GET', 'POST']]]
+
+class _ExternalCoreRequirementsCatalogRequirements(TypedDict, total=False):
+    catalog_type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    required: NotRequired[builtins.bool]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    required_fields: NotRequired[builtins.list[builtins.str]]
+    feed_formats: NotRequired[builtins.list[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'tiktok_shop', 'pinterest_catalog', 'openai_product_feed', 'custom']]]
+    offering_asset_constraints: NotRequired[builtins.list[_ExternalCoreRequirementsOfferingAssetConstraint]]
+    field_bindings: NotRequired[builtins.list[_ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant1 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant2 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3]]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant1(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['image']]
+    requirements: NotRequired[_ExternalCoreRequirementsImageAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant2(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['video']]
+    requirements: NotRequired[_ExternalCoreRequirementsVideoAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant3(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['audio']]
+    requirements: NotRequired[_ExternalCoreRequirementsAudioAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant4(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['text']]
+    requirements: NotRequired[_ExternalCoreRequirementsTextAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant5(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['markdown']]
+    requirements: NotRequired[_ExternalCoreRequirementsMarkdownAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant6(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['html']]
+    requirements: NotRequired[_ExternalCoreRequirementsHtmlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant7(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['css']]
+    requirements: NotRequired[_ExternalCoreRequirementsCssAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant8(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['javascript']]
+    requirements: NotRequired[_ExternalCoreRequirementsJavascriptAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant9(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['zip']]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant10(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['vast']]
+    requirements: NotRequired[_ExternalCoreRequirementsVastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant11(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['daast']]
+    requirements: NotRequired[_ExternalCoreRequirementsDaastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant12(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['url']]
+    requirements: NotRequired[_ExternalCoreRequirementsUrlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant13(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['webhook']]
+    requirements: NotRequired[_ExternalCoreRequirementsWebhookAssetRequirements]
+
+class _ExternalCoreFormatPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreCanonicalProjectionSlotOverride(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[builtins.str]
+    required: NotRequired[builtins.bool]
+    max_chars: NotRequired[builtins.int]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ListCreativesResponseCreativesItemVariant1AssignmentsAssignedPackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    assigned_date: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2AssignmentsAssignedPackagesItem(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    assigned_date: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreTransformerVoiceSynthesisRefItemBrandAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTransformerParamOptionsItem(TypedDict, total=False):
+    value: Required[Any]
+    label: NotRequired[builtins.str]
+    metadata: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreUserMatchUidsItem(TypedDict, total=False):
+    type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]
+    value: Required[builtins.str]
+
+class _ExternalCoreEventCustomDataContentsItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    quantity: NotRequired[builtins.int]
+    price: NotRequired[builtins.float]
+    brand: NotRequired[builtins.str]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageSignalTargetingGroup(TypedDict, total=False):
+    operator: Required[Literal['any', 'none']]
+    signals: Required[builtins.list[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3]]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemInput]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemInput]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipalAccount(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligationJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentityUserShippingAddress(TypedDict, total=False):
+    street: NotRequired[builtins.str]
+    city: NotRequired[builtins.str]
+    state: NotRequired[builtins.str]
+    postal_code: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVoiceVariant2(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    voice_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVideoVariant2(TypedDict, total=False):
+    formats: NotRequired[builtins.list[builtins.str]]
+    max_duration_seconds: NotRequired[builtins.int]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesAvatarVariant2(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    avatar_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceiptDisclosureCommitment(TypedDict, total=False):
+    status: Required[Literal['accepted', 'not_required']]
+    label_text: NotRequired[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _ExternalA2uiComponent(TypedDict, total=False):
+    id: Required[builtins.str]
+    parentId: NotRequired[builtins.str]
+    component: Required[builtins.dict[builtins.str, builtins.dict[builtins.str, Any]]]
+
+class _SiSendMessageResponseHandoffIntentPrice(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant1NotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant2NotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceMemberUidsItem(TypedDict, total=False):
+    type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]
+    value: Required[builtins.str]
+
+class _ExternalCoreEventSourceHealthDetail(TypedDict, total=False):
+    score: Required[builtins.float]
+    max_score: Required[builtins.float]
+    label: NotRequired[builtins.str]
+
+class _SyncGovernanceRequestAccountsItemGovernanceAgentsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemBudgetVariant1AllocationsValue(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _SyncPlansRequestPlansItemBudgetVariant2AllocationsValue(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _SyncPlansRequestPlansItemChannelsMixTargetsValue(TypedDict, total=False):
+    min_pct: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _SyncPlansRequestPlansItemDelegationsItemBudgetLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemPortfolioTotalBudgetCap(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseAdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant1AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant1AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant1PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPublisherPropertiesItemVariant1(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['all']]
+
+class _TasksGetResponseResultVariant1ProductsItemPublisherPropertiesItemVariant2(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemPublisherPropertiesItemVariant3(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['by_tag']]
+    property_tags: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1FormatSchema]
+    format_kind: Required[Literal['image']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2FormatSchema]
+    format_kind: Required[Literal['html5']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3FormatSchema]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3 | _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4FormatSchema]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5FormatSchema]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6FormatSchema]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7FormatSchema]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8FormatSchema]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9FormatSchema]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10FormatSchema]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11FormatSchema]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12FormatSchema]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12Params]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant13V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant13FormatSchema]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItem(TypedDict, total=False):
+    kind: Required[Literal['publisher_ref', 'seller_inline']]
+    placement_id: Required[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    mode: Required[Literal['targetable', 'included']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatIdsItem]]
+    format_options: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant13]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['vcpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpc']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpcv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceGuidance]
+    parameters: Required[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpp']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceGuidance]
+    parameters: Required[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpa']]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    fixed_price: Required[builtins.float]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['flat_rate']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceGuidance]
+    parameters: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['time']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceGuidance]
+    parameters: Required[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecast(TypedDict, total=False):
+    points: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItem]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemOutcomeMeasurement(TypedDict, total=False):
+    type: Required[builtins.str]
+    attribution: Required[builtins.str]
+    window: NotRequired[_TasksGetResponseResultVariant1ProductsItemOutcomeMeasurementWindow]
+    reporting: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurement(TypedDict, total=False):
+    vendors: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItem]]
+    provider: NotRequired[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsMakegoodPolicy]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItem(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendor]
+
+class _TasksGetResponseResultVariant1ProductsItemCancellationPolicy(TypedDict, total=False):
+    notice_period: Required[_TasksGetResponseResultVariant1ProductsItemCancellationPolicyNoticePeriod]
+    cancellation_fee: Required[_TasksGetResponseResultVariant1ProductsItemCancellationPolicyCancellationFee]
+
+class _TasksGetResponseResultVariant1ProductsItemAllowedActionsItem(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    modes: Required[builtins.list[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]]
+    allowed_statuses: NotRequired[builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]]
+    sla: NotRequired[_TasksGetResponseResultVariant1ProductsItemAllowedActionsItemSla]
+    terms_ref: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilities(TypedDict, total=False):
+    available_reporting_frequencies: Required[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    expected_delay_minutes: Required[builtins.int]
+    timezone: Required[builtins.str]
+    supports_webhooks: Required[builtins.bool]
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    vendor_metrics: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItem]]
+    supports_creative_breakdown: NotRequired[builtins.bool]
+    supports_keyword_breakdown: NotRequired[builtins.bool]
+    supports_geo_breakdown: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesSupportsGeoBreakdown]
+    supports_device_type_breakdown: NotRequired[builtins.bool]
+    supports_device_platform_breakdown: NotRequired[builtins.bool]
+    supports_audience_breakdown: NotRequired[builtins.bool]
+    supports_placement_breakdown: NotRequired[builtins.bool]
+    date_range_support: Required[Literal['date_range', 'lifetime_only']]
+    windowed_pull_granularities: NotRequired[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    measurement_windows: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesMeasurementWindowsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemCreativePolicy(TypedDict, total=False):
+    co_branding: Required[Literal['required', 'optional', 'none']]
+    landing_page: Required[Literal['any', 'retailer_site_only', 'must_include_retailer']]
+    templates_available: Required[builtins.bool]
+    provenance_required: NotRequired[builtins.bool]
+    provenance_requirements: NotRequired[_TasksGetResponseResultVariant1ProductsItemCreativePolicyProvenanceRequirements]
+    accepted_verifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemCreativePolicyAcceptedVerifiersItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemDataProviderSignalsItemVariant1(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['all']]
+
+class _TasksGetResponseResultVariant1ProductsItemDataProviderSignalsItemVariant2(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    signal_ids: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemDataProviderSignalsItemVariant3(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_tag']]
+    signal_tags: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItem(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalRefVariant1 | _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalRefVariant2 | _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalIdVariant1 | _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemRange]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItem(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalRefVariant1 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalRefVariant2 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalIdVariant1 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemRange]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_status: NotRequired[Literal['ready', 'requires_activation']]
+    allowed_targeting_modes: NotRequired[builtins.list[Literal['include', 'exclude']]]
+    default_selected: NotRequired[builtins.bool]
+    selection_group: NotRequired[builtins.str]
+    pricing_options: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant2 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant3 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant4 | _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant5]]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingRules(TypedDict, total=False):
+    resolution_model: NotRequired[Literal['direct_targeting', 'seller_planned']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+    max_selected_per_group: NotRequired[builtins.int]
+    max_signal_targeting_groups: NotRequired[builtins.int]
+    max_signals_per_targeting_group: NotRequired[builtins.int]
+    selection_group_rules: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingRulesSelectionGroupRulesItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    supported_reach_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_view_durations: NotRequired[builtins.list[builtins.float]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementReadiness(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    required_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    missing_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemMeasurementReadinessIssuesItem]]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemConversionTracking(TypedDict, total=False):
+    action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    platform_managed: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemCatalogMatch(TypedDict, total=False):
+    matched_gtins: NotRequired[builtins.list[builtins.str]]
+    matched_ids: NotRequired[builtins.list[builtins.str]]
+    matched_count: NotRequired[builtins.int]
+    submitted_count: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCard(TypedDict, total=False):
+    image: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImage]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailed(TypedDict, total=False):
+    hero_image: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImage]
+    carousel_images: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItem]]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    specifications: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedSpecificationsItem]]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemCollectionsItem(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItem(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    collection_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    season: NotRequired[builtins.str]
+    installment_number: NotRequired[builtins.str]
+    scheduled_at: NotRequired[builtins.str]
+    status: NotRequired[Literal['scheduled', 'tentative', 'live', 'postponed', 'cancelled', 'aired', 'published']]
+    duration_seconds: NotRequired[builtins.int]
+    flexible_end: NotRequired[builtins.bool]
+    valid_until: NotRequired[builtins.str]
+    content_rating: NotRequired[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemContentRating]
+    topics: NotRequired[builtins.list[builtins.str]]
+    special: NotRequired[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemSpecial]
+    guest_talent: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemGuestTalentItem]]
+    ad_inventory: NotRequired[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemAdInventory]
+    deadlines: NotRequired[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemDeadlines]
+    derivative_of: NotRequired[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemDerivativeOf]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemTrustedMatch(TypedDict, total=False):
+    context_match: Required[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+    dynamic_brands: NotRequired[builtins.bool]
+    providers: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemTrustedMatchProvidersItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemMaterialSubmission(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    instructions: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    allocation_percentage: Required[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    rationale: NotRequired[builtins.str]
+    sequence: NotRequired[builtins.int]
+    tags: NotRequired[builtins.list[builtins.str]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    daypart_targets: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemDaypartTargetsItem]]
+    forecast: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemInsertionOrder(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    terms: NotRequired[_TasksGetResponseResultVariant1ProposalsItemInsertionOrderTerms]
+    terms_url: NotRequired[builtins.str]
+    signing_url: NotRequired[builtins.str]
+    requires_signature: Required[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProposalsItemTotalBudgetGuidance(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    recommended: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecast(TypedDict, total=False):
+    points: Required[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItem]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant1ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant1IncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant1FilterDiagnosticsExcludedByValue(TypedDict, total=False):
+    count: Required[builtins.int]
+    values: NotRequired[builtins.list[builtins.str | builtins.dict[builtins.str, Any]]]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPublisherPropertiesItemVariant1(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['all']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPublisherPropertiesItemVariant2(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPublisherPropertiesItemVariant3(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['by_tag']]
+    property_tags: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1FormatSchema]
+    format_kind: Required[Literal['image']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2FormatSchema]
+    format_kind: Required[Literal['html5']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3FormatSchema]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3 | _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4FormatSchema]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5FormatSchema]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6FormatSchema]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7FormatSchema]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8FormatSchema]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9FormatSchema]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10FormatSchema]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11FormatSchema]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12FormatSchema]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant13V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant13FormatSchema]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItem(TypedDict, total=False):
+    kind: Required[Literal['publisher_ref', 'seller_inline']]
+    placement_id: Required[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    mode: Required[Literal['targetable', 'included']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatIdsItem]]
+    format_options: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant13]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['vcpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpc']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpcv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceGuidance]
+    parameters: Required[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpp']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceGuidance]
+    parameters: Required[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpa']]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    fixed_price: Required[builtins.float]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['flat_rate']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceGuidance]
+    parameters: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['time']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceGuidance]
+    parameters: Required[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecast(TypedDict, total=False):
+    points: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItem]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemOutcomeMeasurement(TypedDict, total=False):
+    type: Required[builtins.str]
+    attribution: Required[builtins.str]
+    window: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemOutcomeMeasurementWindow]
+    reporting: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurement(TypedDict, total=False):
+    vendors: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItem]]
+    provider: NotRequired[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsMakegoodPolicy]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItem(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendor]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCancellationPolicy(TypedDict, total=False):
+    notice_period: Required[_TasksGetResponseResultVariant3PartialResultsItemCancellationPolicyNoticePeriod]
+    cancellation_fee: Required[_TasksGetResponseResultVariant3PartialResultsItemCancellationPolicyCancellationFee]
+
+class _TasksGetResponseResultVariant3PartialResultsItemAllowedActionsItem(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    modes: Required[builtins.list[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]]
+    allowed_statuses: NotRequired[builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]]
+    sla: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemAllowedActionsItemSla]
+    terms_ref: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilities(TypedDict, total=False):
+    available_reporting_frequencies: Required[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    expected_delay_minutes: Required[builtins.int]
+    timezone: Required[builtins.str]
+    supports_webhooks: Required[builtins.bool]
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    vendor_metrics: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItem]]
+    supports_creative_breakdown: NotRequired[builtins.bool]
+    supports_keyword_breakdown: NotRequired[builtins.bool]
+    supports_geo_breakdown: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesSupportsGeoBreakdown]
+    supports_device_type_breakdown: NotRequired[builtins.bool]
+    supports_device_platform_breakdown: NotRequired[builtins.bool]
+    supports_audience_breakdown: NotRequired[builtins.bool]
+    supports_placement_breakdown: NotRequired[builtins.bool]
+    date_range_support: Required[Literal['date_range', 'lifetime_only']]
+    windowed_pull_granularities: NotRequired[builtins.list[Literal['hourly', 'daily', 'monthly']]]
+    measurement_windows: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesMeasurementWindowsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCreativePolicy(TypedDict, total=False):
+    co_branding: Required[Literal['required', 'optional', 'none']]
+    landing_page: Required[Literal['any', 'retailer_site_only', 'must_include_retailer']]
+    templates_available: Required[builtins.bool]
+    provenance_required: NotRequired[builtins.bool]
+    provenance_requirements: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemCreativePolicyProvenanceRequirements]
+    accepted_verifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemCreativePolicyAcceptedVerifiersItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDataProviderSignalsItemVariant1(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['all']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDataProviderSignalsItemVariant2(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    signal_ids: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDataProviderSignalsItemVariant3(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_tag']]
+    signal_tags: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItem(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalRefVariant1 | _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalRefVariant2 | _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalIdVariant1 | _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemRange]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItem(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalRefVariant1 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalRefVariant2 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalIdVariant1 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemRange]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_status: NotRequired[Literal['ready', 'requires_activation']]
+    allowed_targeting_modes: NotRequired[builtins.list[Literal['include', 'exclude']]]
+    default_selected: NotRequired[builtins.bool]
+    selection_group: NotRequired[builtins.str]
+    pricing_options: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant3 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant4 | _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant5]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingRules(TypedDict, total=False):
+    resolution_model: NotRequired[Literal['direct_targeting', 'seller_planned']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+    max_selected_per_group: NotRequired[builtins.int]
+    max_signal_targeting_groups: NotRequired[builtins.int]
+    max_signals_per_targeting_group: NotRequired[builtins.int]
+    selection_group_rules: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingRulesSelectionGroupRulesItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    supported_reach_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_view_durations: NotRequired[builtins.list[builtins.float]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementReadiness(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    required_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    missing_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemMeasurementReadinessIssuesItem]]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemConversionTracking(TypedDict, total=False):
+    action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    platform_managed: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCatalogMatch(TypedDict, total=False):
+    matched_gtins: NotRequired[builtins.list[builtins.str]]
+    matched_ids: NotRequired[builtins.list[builtins.str]]
+    matched_count: NotRequired[builtins.int]
+    submitted_count: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCard(TypedDict, total=False):
+    image: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImage]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailed(TypedDict, total=False):
+    hero_image: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImage]
+    carousel_images: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItem]]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    specifications: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedSpecificationsItem]]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCollectionsItem(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItem(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    collection_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    season: NotRequired[builtins.str]
+    installment_number: NotRequired[builtins.str]
+    scheduled_at: NotRequired[builtins.str]
+    status: NotRequired[Literal['scheduled', 'tentative', 'live', 'postponed', 'cancelled', 'aired', 'published']]
+    duration_seconds: NotRequired[builtins.int]
+    flexible_end: NotRequired[builtins.bool]
+    valid_until: NotRequired[builtins.str]
+    content_rating: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemContentRating]
+    topics: NotRequired[builtins.list[builtins.str]]
+    special: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemSpecial]
+    guest_talent: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemGuestTalentItem]]
+    ad_inventory: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemAdInventory]
+    deadlines: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemDeadlines]
+    derivative_of: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemDerivativeOf]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemTrustedMatch(TypedDict, total=False):
+    context_match: Required[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+    dynamic_brands: NotRequired[builtins.bool]
+    providers: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemTrustedMatchProvidersItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMaterialSubmission(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    instructions: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant4ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant4ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant5AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant5AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant5PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Never]
+    signal_id: Required[builtins.str]
+    data_provider_domain: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Never]
+    signal_id: Required[builtins.str]
+    signal_source_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant4(TypedDict, total=False):
+    scope: Required[Never]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant5(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant6(TypedDict, total=False):
+    scope: Required[Never]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+    signal_source_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant7(TypedDict, total=False):
+    scope: Required[Never]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant8(TypedDict, total=False):
+    scope: Required[Never]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+    data_provider_domain: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalRefVariant9(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemTaxonomy(TypedDict, total=False):
+    ref: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    segtax: NotRequired[builtins.int]
+    etag: NotRequired[builtins.str]
+    values: Required[builtins.list[_TasksGetResponseResultVariant5SignalsItemTaxonomyValuesItem]]
+    value_mappings: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemTaxonomyValueMappingsItem]]
+    parent_match_behavior: NotRequired[Literal['exact_only', 'descendants_supported', 'unknown']]
+
+class _TasksGetResponseResultVariant5SignalsItemOnboarder(TypedDict, total=False):
+    match_keys: Required[builtins.list[Literal['name', 'address', 'email', 'postal', 'lat_long', 'mobile_id', 'cookie_id', 'ip', 'customer_id', 'phone']]]
+    pre_onboarding_audience_expansion: NotRequired[builtins.bool]
+    pre_onboarding_device_expansion: NotRequired[builtins.bool]
+    pre_onboarding_precision_level: NotRequired[Literal['individual', 'household', 'business', 'geography']]
+
+class _TasksGetResponseResultVariant5SignalsItemModeling(TypedDict, total=False):
+    method: Required[Literal['lookalike', 'supervised', 'embedding', 'rules']]
+    seed_source: Required[_TasksGetResponseResultVariant5SignalsItemModelingSeedSource]
+    training_data_jurisdictions: Required[builtins.list[builtins.str]]
+    ai_act_risk_class: Required[Literal['minimal', 'limited', 'high_risk']]
+    disclosure: NotRequired[_TasksGetResponseResultVariant5SignalsItemModelingDisclosure]
+
+class _TasksGetResponseResultVariant5SignalsItemDataSubjectRights(TypedDict, total=False):
+    upstream_source_domain: NotRequired[builtins.str]
+    channels: Required[builtins.list[_TasksGetResponseResultVariant5SignalsItemDataSubjectRightsChannelsItem]]
+    response_sla_days: NotRequired[builtins.int]
+    ccpa_opt_out_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecast(TypedDict, total=False):
+    points: Required[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItem]]
+    forecast_range_unit: Required[Literal['availability']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    scope: Required[_TasksGetResponseResultVariant5SignalsItemCoverageForecastScope]
+    bucket_semantics: Required[Literal['exclusive', 'overlapping']]
+    bucket_completeness: Required[Literal['complete', 'partial']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant1ActivationKeyVariant1 | _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant2ActivationKeyVariant1 | _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant1AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant2AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant3AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant4AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant5AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant5ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant5IncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant7ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant7ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant8Variant1AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant8Variant1PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant8Variant1AccountBillingEntity(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBillingEntityAddress]
+    contacts: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountBillingEntityContactsItem]]
+    bank: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBillingEntityBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1AccountCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountNotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['scheduled', 'final', 'delayed', 'adjusted', 'impairment', 'creative.status_changed', 'creative.purged', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    authentication: NotRequired[_TasksGetResponseResultVariant8Variant1AccountNotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1InvoiceRecipientAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1InvoiceRecipientContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1InvoiceRecipientBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AvailableActionsItemSla(TypedDict, total=False):
+    response_max: NotRequired[builtins.str]
+    completion_max: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemPriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemPriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCatalogsItem(TypedDict, total=False):
+    catalog_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    url: NotRequired[builtins.str]
+    feed_format: NotRequired[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'tiktok_shop', 'pinterest_catalog', 'openai_product_feed', 'custom']]
+    update_frequency: NotRequired[Literal['realtime', 'hourly', 'daily', 'weekly']]
+    items: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    ids: NotRequired[builtins.list[builtins.str]]
+    gtins: NotRequired[builtins.list[builtins.str]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    category: NotRequired[builtins.str]
+    query: NotRequired[builtins.str]
+    conversion_events: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+    feed_field_mappings: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCatalogsItemFeedFieldMappingsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlay(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.list[builtins.str]]
+    geo_countries_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_regions: NotRequired[builtins.list[builtins.str]]
+    geo_regions_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_metros: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoMetrosItem]]
+    geo_metros_exclude: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoMetrosExcludeItem]]
+    geo_postal_areas: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasItemVariant2]]
+    geo_postal_areas_exclude: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant2]]
+    daypart_targets: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayDaypartTargetsItem]]
+    axe_include_segment: NotRequired[builtins.str]
+    axe_exclude_segment: NotRequired[builtins.str]
+    audience_include: NotRequired[builtins.list[builtins.str]]
+    audience_exclude: NotRequired[builtins.list[builtins.str]]
+    signal_targeting_groups: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroups]
+    signal_targeting: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3]]
+    frequency_cap: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayFrequencyCap]
+    property_list: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayPropertyList]
+    collection_list: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayCollectionList]
+    collection_list_exclude: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayCollectionListExclude]
+    age_restriction: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayAgeRestriction]
+    device_platform: NotRequired[builtins.list[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]]
+    device_type: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    device_type_exclude: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    store_catchments: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayStoreCatchmentsItem]]
+    geo_proximity: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3]]
+    language: NotRequired[builtins.list[builtins.str]]
+    keyword_targets: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayKeywordTargetsItem]]
+    negative_keywords: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayNegativeKeywordsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsMakegoodPolicy]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItem(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendor]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant1Qualifier]
+    committed_at: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2Vendor]
+    metric_id: Required[builtins.str]
+    committed_at: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCreativeAssignmentsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCreativeAssignmentsItemPlacementRefsItem]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemFormatIdsToProvideItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2TargetVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2TargetVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3Vendor]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3TargetVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+    acknowledged_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryGeo(TypedDict, total=False):
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryFrequencyCap(TypedDict, total=False):
+    suppress: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryFrequencyCapSuppress]
+    suppress_minutes: NotRequired[builtins.float]
+    max_impressions: NotRequired[builtins.int]
+    per: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    window: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryFrequencyCapWindow]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1 | _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant2AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant2AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant8Variant2PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant2ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant2ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant8Variant3AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant3AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant8Variant3PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant3ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant3ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant10ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant10ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant11ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant11ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant12Variant1AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant12Variant1PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1InvoiceRecipientAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1InvoiceRecipientContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1InvoiceRecipientBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCatalogsItem(TypedDict, total=False):
+    catalog_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    url: NotRequired[builtins.str]
+    feed_format: NotRequired[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'tiktok_shop', 'pinterest_catalog', 'openai_product_feed', 'custom']]
+    update_frequency: NotRequired[Literal['realtime', 'hourly', 'daily', 'weekly']]
+    items: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    ids: NotRequired[builtins.list[builtins.str]]
+    gtins: NotRequired[builtins.list[builtins.str]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    category: NotRequired[builtins.str]
+    query: NotRequired[builtins.str]
+    conversion_events: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+    feed_field_mappings: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCatalogsItemFeedFieldMappingsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlay(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.list[builtins.str]]
+    geo_countries_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_regions: NotRequired[builtins.list[builtins.str]]
+    geo_regions_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_metros: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoMetrosItem]]
+    geo_metros_exclude: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoMetrosExcludeItem]]
+    geo_postal_areas: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasItemVariant2]]
+    geo_postal_areas_exclude: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant2]]
+    daypart_targets: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayDaypartTargetsItem]]
+    axe_include_segment: NotRequired[builtins.str]
+    axe_exclude_segment: NotRequired[builtins.str]
+    audience_include: NotRequired[builtins.list[builtins.str]]
+    audience_exclude: NotRequired[builtins.list[builtins.str]]
+    signal_targeting_groups: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroups]
+    signal_targeting: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3]]
+    frequency_cap: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayFrequencyCap]
+    property_list: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayPropertyList]
+    collection_list: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayCollectionList]
+    collection_list_exclude: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayCollectionListExclude]
+    age_restriction: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayAgeRestriction]
+    device_platform: NotRequired[builtins.list[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]]
+    device_type: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    device_type_exclude: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    store_catchments: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayStoreCatchmentsItem]]
+    geo_proximity: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3]]
+    language: NotRequired[builtins.list[builtins.str]]
+    keyword_targets: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayKeywordTargetsItem]]
+    negative_keywords: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayNegativeKeywordsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsMakegoodPolicy]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItem(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendor]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant1Qualifier]
+    committed_at: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2Vendor]
+    metric_id: Required[builtins.str]
+    committed_at: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCreativeAssignmentsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCreativeAssignmentsItemPlacementRefsItem]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemFormatIdsToProvideItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2TargetVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2TargetVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3Vendor]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3TargetVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+    acknowledged_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AvailableActionsItemSla(TypedDict, total=False):
+    response_max: NotRequired[builtins.str]
+    completion_max: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant2AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant2AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant12Variant2PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant2ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant2ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant12Variant3AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant3AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant12Variant3PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant3ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant3ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant15ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant15ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant16AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant16AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotals(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsQuartileData | _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsQuartileData2]
+    dooh_metrics: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsDoohMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItem]]
+    effective_rate: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemQuartileData | _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemQuartileData2]
+    dooh_metrics: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemDoohMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItem]]
+    package_id: NotRequired[builtins.str]
+    pacing_index: NotRequired[builtins.float]
+    pricing_model: NotRequired[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'flat_rate', 'time']]
+    rate: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    delivery_status: NotRequired[Literal['delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    paused: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    measurement_window: NotRequired[builtins.str]
+    supersedes_window: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant16ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant1AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant1PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1FormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1RightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1RightsItemRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1IndustryIdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1Provenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2FormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2RightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2RightsItemRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2IndustryIdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2Provenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant1 | _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant2 | _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant3]]
+    input: Required[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemInput]
+
+class _TasksGetResponseResultVariant17Variant1PreviewErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1PreviewErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant2AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant2PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1FormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1RightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1RightsItemRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1IndustryIdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1Provenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2FormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2RightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2RightsItemRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2IndustryIdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2Provenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    format_id: Required[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemFormatId]
+    renders: Required[builtins.list[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant1 | _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant2 | _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant3]]
+    input: Required[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemInput]
+
+class _TasksGetResponseResultVariant17Variant2PreviewErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2PreviewErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant3AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant3PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemCatalogItemRef(TypedDict, total=False):
+    catalog_type: NotRequired[builtins.str]
+    item_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalRefVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalRefVariant2 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalIdVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalRefVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalRefVariant2 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalIdVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalRefVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalRefVariant2 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalIdVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItem(TypedDict, total=False):
+    build_variant_id: Required[builtins.str]
+    recipe_hash: NotRequired[builtins.str]
+    parent_build_variant_id: NotRequired[builtins.str]
+    creative_manifest: Required[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2]
+    variant_axis_value: NotRequired[Any]
+    recommended: NotRequired[builtins.bool]
+    rank: NotRequired[builtins.int]
+    eval: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemEval]
+    pricing_option_id: NotRequired[builtins.str]
+    vendor_cost: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    consumption: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemConsumption]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant4AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant4AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant4PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant4EstimatePerLeafItem(TypedDict, total=False):
+    catalog_item_ref: NotRequired[builtins.dict[builtins.str, Any]]
+    variant_axis_value: NotRequired[Any]
+    pricing_option_id: NotRequired[builtins.str]
+    cost_low: NotRequired[builtins.float]
+    cost_high: NotRequired[builtins.float]
+    consumption_estimate: NotRequired[_TasksGetResponseResultVariant17Variant4EstimatePerLeafItemConsumptionEstimate]
+
+class _TasksGetResponseResultVariant17Variant5AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant5AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant5PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant5ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant5ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant6AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant6AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant6PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant6ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant6ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant19ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant19ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant20ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant20ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant21Variant1AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant21Variant1PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccount(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrand]
+    operator: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntity]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountCreditLimit]
+    setup: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountNotificationConfigsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant2AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant2AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant21Variant2PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant2ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant2ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant21Variant3AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant3AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant21Variant3PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant3ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant3ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant24ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant24ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant25Variant1AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant1AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant25Variant1PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant1CatalogsItemItemIssuesItem(TypedDict, total=False):
+    item_id: Required[builtins.str]
+    status: Required[Literal['approved', 'pending', 'rejected', 'warning', 'withdrawn']]
+    reasons: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant25Variant1CatalogsItemErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant1CatalogsItemErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant2AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant2AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant25Variant2PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant2ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant2ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant25Variant3AdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant3AdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant25Variant3PushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseResultVariant25Variant3ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant3ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant28ErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant28ErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksListRequestAccountVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksListResponseAdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalPropertyValidationResultFeaturesItemRequirement(TypedDict, total=False):
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    allowed_values: NotRequired[builtins.list[Any]]
+
+class _ExternalPropertyAuthorizationResultViolation(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+
+class _SignedResponsePayloadResponse(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary', 'parent', 'property', 'trademark']]
+    verification_status: Required[Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown']]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    context_note: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant3ClaimProperty(TypedDict, total=False):
+    type: Required[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'streaming_audio']]
+    identifier: Required[builtins.str]
+    store: NotRequired[Literal['apple', 'google', 'amazon', 'roku', 'fire_tv', 'samsung', 'lg', 'vizio', 'other']]
+    region: NotRequired[builtins.str]
+
+class _SignedResponse2PayloadResponse(TypedDict, total=False):
+    results: Required[builtins.list[_SignedResponse2PayloadResponseResultsItemVariant1 | _SignedResponse2PayloadResponseResultsItemVariant2]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_ExternalCoreProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoMetros(TypedDict, total=False):
+    nielsen_dma: NotRequired[builtins.bool]
+    uk_itl1: NotRequired[builtins.bool]
+    uk_itl2: NotRequired[builtins.bool]
+    eurostat_nuts2: NotRequired[builtins.bool]
+
+class _ExternalCorePostalAreaSupport(TypedDict, total=False):
+    US: NotRequired[builtins.list[Literal['zip', 'zip_plus_four']]]
+    GB: NotRequired[builtins.list[Literal['outward', 'full']]]
+    CA: NotRequired[builtins.list[Literal['fsa', 'full']]]
+    DE: NotRequired[builtins.list[Literal['plz']]]
+    CH: NotRequired[builtins.list[Literal['plz']]]
+    AT: NotRequired[builtins.list[Literal['plz']]]
+    FR: NotRequired[builtins.list[Literal['code_postal']]]
+    AU: NotRequired[builtins.list[Literal['postcode']]]
+    BR: NotRequired[builtins.list[Literal['cep']]]
+    IN: NotRequired[builtins.list[Literal['pin']]]
+    ZA: NotRequired[builtins.list[Literal['postal_code']]]
+    us_zip: NotRequired[builtins.bool]
+    us_zip_plus_four: NotRequired[builtins.bool]
+    gb_outward: NotRequired[builtins.bool]
+    gb_full: NotRequired[builtins.bool]
+    ca_fsa: NotRequired[builtins.bool]
+    ca_full: NotRequired[builtins.bool]
+    de_plz: NotRequired[builtins.bool]
+    fr_code_postal: NotRequired[builtins.bool]
+    au_postcode: NotRequired[builtins.bool]
+    ch_plz: NotRequired[builtins.bool]
+    at_plz: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingAgeRestriction(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    verification_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingKeywordTargets(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingNegativeKeywords(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoProximity(TypedDict, total=False):
+    radius: NotRequired[builtins.bool]
+    travel_time: NotRequired[builtins.bool]
+    geometry: NotRequired[builtins.bool]
+    transport_modes: NotRequired[builtins.list[Literal['walking', 'cycling', 'driving', 'public_transport']]]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeVariantReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCreativeVariantDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreCreativeVariantGenerationContextArtifact(TypedDict, total=False):
+    property_id: Required[_ExternalCoreIdentifier]
+    artifact_id: Required[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCoreCatalogItemDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCatalogItemDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreCatalogItemDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCatalogItemDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCatalogItemDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCatalogItemDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCatalogItemDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreCreativeDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreCreativeDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCreativeDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCreativeDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreKeywordDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreKeywordDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreKeywordDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreKeywordDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreGeoDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreGeoDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreGeoDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreGeoDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryDriftMetricsThresholds(TypedDict, total=False):
+    escalation_rate_max: NotRequired[builtins.float]
+    escalation_rate_min: NotRequired[builtins.float]
+    auto_approval_rate_max: NotRequired[builtins.float]
+    human_override_rate_max: NotRequired[builtins.float]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreDownstreamConnectionRequirement(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_ExternalCoreDownstreamConnectionRequirementResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalFormatsCanonicalImageCarouselSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalVideoHostedSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalVideoVastSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAudioHostedSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAudioDaastSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalSponsoredPlacementSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalNativeInFeedSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalNativeInFeedMainImageSizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalFormatsCanonicalNativeInFeedIconSize(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalFormatsCanonicalResponsiveCreativeSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAgentPlacementSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductPricingOptionsItemVariant5ParametersViewThresholdVariant2(TypedDict, total=False):
+    duration_seconds: Required[builtins.int]
+
+class _ExternalCoreForecastPointDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_ExternalCorePlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _ExternalCoreForecastPointDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _ExternalCoreForecastPointDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant1 | _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant2 | _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_ExternalCoreForecastRange]
+    reach: NotRequired[_ExternalCoreForecastRange]
+    frequency: NotRequired[_ExternalCoreForecastRange]
+    impressions: NotRequired[_ExternalCoreForecastRange]
+    clicks: NotRequired[_ExternalCoreForecastRange]
+    spend: NotRequired[_ExternalCoreForecastRange]
+    views: NotRequired[_ExternalCoreForecastRange]
+    completed_views: NotRequired[_ExternalCoreForecastRange]
+    grps: NotRequired[_ExternalCoreForecastRange]
+    engagements: NotRequired[_ExternalCoreForecastRange]
+    follows: NotRequired[_ExternalCoreForecastRange]
+    saves: NotRequired[_ExternalCoreForecastRange]
+    profile_visits: NotRequired[_ExternalCoreForecastRange]
+    measured_impressions: NotRequired[_ExternalCoreForecastRange]
+    downloads: NotRequired[_ExternalCoreForecastRange]
+    plays: NotRequired[_ExternalCoreForecastRange]
+    coverage_rate: NotRequired[_ExternalCoreForecastPointMetricsCoverageRate]
+
+class _ExternalCoreForecastPointViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_rate: NotRequired[_ExternalCoreForecastPointViewabilityViewableRate]
+    viewed_seconds: NotRequired[_ExternalCoreForecastRange]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreForecastVendorMetricValue(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    value: Required[_ExternalCoreForecastRange]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreMaterialDeadline(TypedDict, total=False):
+    stage: Required[builtins.str]
+    due_at: Required[builtins.str]
+    label: NotRequired[builtins.str]
+
+class _ExternalCoreInsertionOrderTermsTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreSignalModelingDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    disclosure_text: NotRequired[builtins.str]
+    disclosure_url: NotRequired[builtins.str]
+    audience: NotRequired[Literal['buyer', 'data_subject', 'regulator', 'public']]
+
+class _ExternalCoreSignalCoverageForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_ExternalCoreForecastRange]
+    reach: NotRequired[_ExternalCoreForecastRange]
+    frequency: NotRequired[_ExternalCoreForecastRange]
+    impressions: NotRequired[_ExternalCoreForecastRange]
+    clicks: NotRequired[_ExternalCoreForecastRange]
+    spend: NotRequired[_ExternalCoreForecastRange]
+    views: NotRequired[_ExternalCoreForecastRange]
+    completed_views: NotRequired[_ExternalCoreForecastRange]
+    grps: NotRequired[_ExternalCoreForecastRange]
+    engagements: NotRequired[_ExternalCoreForecastRange]
+    follows: NotRequired[_ExternalCoreForecastRange]
+    saves: NotRequired[_ExternalCoreForecastRange]
+    profile_visits: NotRequired[_ExternalCoreForecastRange]
+    measured_impressions: NotRequired[_ExternalCoreForecastRange]
+    downloads: NotRequired[_ExternalCoreForecastRange]
+    plays: NotRequired[_ExternalCoreForecastRange]
+    coverage_rate: Required[_ExternalCoreSignalCoverageForecastPointsItemMetricsCoverageRate]
+
+class _ExternalCoreSignalCoverageForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_rate: NotRequired[_ExternalCoreSignalCoverageForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_ExternalCoreForecastRange]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreFormatRendersItemVariant1DimensionsResponsive(TypedDict, total=False):
+    width: Required[builtins.bool]
+    height: Required[builtins.bool]
+
+class _ExternalCoreFormatRendersItemVariant2DimensionsResponsive(TypedDict, total=False):
+    width: Required[builtins.bool]
+    height: Required[builtins.bool]
+
+class _ExternalCoreOverlayVisual(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    light: NotRequired[builtins.str]
+    dark: NotRequired[builtins.str]
+
+class _ExternalCoreOverlayBounds(TypedDict, total=False):
+    x: Required[builtins.float]
+    y: Required[builtins.float]
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+    unit: Required[Literal['px', 'fraction', 'inches', 'cm', 'mm', 'pt']]
+
+class _ExternalCoreRequirementsImageAssetRequirementsBleedVariant1(TypedDict, total=False):
+    uniform: Required[builtins.float]
+
+class _ExternalCoreRequirementsImageAssetRequirementsBleedVariant2(TypedDict, total=False):
+    top: Required[builtins.float]
+    right: Required[builtins.float]
+    bottom: Required[builtins.float]
+    left: Required[builtins.float]
+
+class _ExternalCoreRequirementsOfferingAssetConstraint(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']]
+    required: NotRequired[builtins.bool]
+    min_count: NotRequired[builtins.int]
+    max_count: NotRequired[builtins.int]
+    asset_requirements: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['scalar']]
+    asset_id: Required[builtins.str]
+    catalog_field: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['asset_pool']]
+    asset_id: Required[builtins.str]
+    asset_group_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['catalog_group']]
+    format_group_id: Required[builtins.str]
+    catalog_item: Required[Literal[True]]
+    per_item_bindings: NotRequired[builtins.list[_ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant1 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant2]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1(TypedDict, total=False):
+    signal_ref: Required[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant3]
+    value_type: Required[Literal['binary']]
+    value: Required[Literal[True]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant2]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2(TypedDict, total=False):
+    signal_ref: Required[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant3]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant2]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3(TypedDict, total=False):
+    signal_ref: Required[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant3]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant2]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    card_aspect_ratio: NotRequired[builtins.str]
+    min_cards: NotRequired[builtins.int]
+    max_cards: NotRequired[builtins.int]
+    allowed_card_media_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    allowed_card_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    card_image_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_duration_ms: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    card_headline_max_chars: NotRequired[builtins.int]
+    card_description_max_chars: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    min_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    video_codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'mp3', 'opus', 'pcm']]]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    max_file_size_mb: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    captions: NotRequired[Literal['required', 'recommended', 'not_required']]
+    om_sdk_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    companion_banner_widths: NotRequired[builtins.list[builtins.int]]
+    companion_banner_heights: NotRequired[builtins.list[builtins.int]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+    vpaid_enabled: NotRequired[builtins.bool]
+    vpaid_version: NotRequired[Literal['1.0', '2.0']]
+    simid_supported: NotRequired[builtins.bool]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    skippable_after_ms: NotRequired[builtins.int]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    audio_codecs: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'opus', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+    companion_image_required: NotRequired[builtins.bool]
+    companion_image_aspect_ratio: NotRequired[builtins.str]
+    companion_image_max_file_size_kb: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    daast_version: NotRequired[Literal['1.0', '1.1']]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+    companion_image_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    supported_catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    fanout_mode: NotRequired[Literal['per_item', 'multi_item_in_creative', 'single_item']]
+    required_catalog_fields: NotRequired[builtins.list[builtins.str]]
+    supported_id_types: NotRequired[builtins.list[Literal['asin', 'sku', 'gtin', 'offering_id', 'store_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'program_id', 'destination_id', 'app_id', 'job_id']]]
+    hero_asset_supported: NotRequired[builtins.bool]
+    item_production_model: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    title_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    main_image_sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsMainImageSizesItem]]
+    icon_size: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsIconSize]
+    max_image_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp']]]
+    ssl_required: NotRequired[builtins.bool]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    headlines_min: NotRequired[builtins.int]
+    headlines_max: NotRequired[builtins.int]
+    headline_max_chars: NotRequired[builtins.int]
+    long_headlines_min: NotRequired[builtins.int]
+    long_headlines_max: NotRequired[builtins.int]
+    long_headline_max_chars: NotRequired[builtins.int]
+    descriptions_min: NotRequired[builtins.int]
+    descriptions_max: NotRequired[builtins.int]
+    description_max_chars: NotRequired[builtins.int]
+    images_landscape_min: NotRequired[builtins.int]
+    images_landscape_max: NotRequired[builtins.int]
+    images_landscape_aspect_ratio: NotRequired[builtins.str]
+    images_square_min: NotRequired[builtins.int]
+    images_square_max: NotRequired[builtins.int]
+    images_vertical_min: NotRequired[builtins.int]
+    images_vertical_max: NotRequired[builtins.int]
+    videos_min: NotRequired[builtins.int]
+    videos_max: NotRequired[builtins.int]
+    video_min_duration_ms: NotRequired[builtins.int]
+    video_max_duration_ms: NotRequired[builtins.int]
+    logo_min: NotRequired[builtins.int]
+    logo_max: NotRequired[builtins.int]
+    logo_aspect_ratios: NotRequired[builtins.list[builtins.str]]
+    business_name_max_chars: NotRequired[builtins.int]
+    asset_image_max_file_size_kb: NotRequired[builtins.int]
+    supports_catalog_input: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    output_modality: NotRequired[Literal['text', 'audio', 'card']]
+    max_mention_length_chars: NotRequired[builtins.int]
+    max_mention_duration_ms: NotRequired[builtins.int]
+    supports_offering_reference: NotRequired[builtins.bool]
+    supports_landing_page_url: NotRequired[builtins.bool]
+    tone_constraints: NotRequired[builtins.list[builtins.str]]
+    disclosure_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant13V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant13FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1FormatSchema]
+    format_kind: Required[Literal['image']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2FormatSchema]
+    format_kind: Required[Literal['html5']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3FormatSchema]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3 | _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4FormatSchema]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5FormatSchema]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6FormatSchema]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7FormatSchema]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8FormatSchema]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9FormatSchema]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10FormatSchema]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11FormatSchema]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12FormatSchema]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12Params]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant13V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant13FormatSchema]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5Parameters(TypedDict, total=False):
+    view_threshold: Required[builtins.float | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5ParametersViewThresholdVariant2]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6Parameters(TypedDict, total=False):
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: Required[builtins.str]
+    min_points: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8Parameters(TypedDict, total=False):
+    type: Required[Literal['dooh']]
+    sov_percentage: NotRequired[builtins.float]
+    loop_duration_seconds: NotRequired[builtins.int]
+    min_plays_per_hour: NotRequired[builtins.int]
+    venue_package: NotRequired[builtins.str]
+    duration_hours: NotRequired[builtins.float]
+    daypart: NotRequired[builtins.str]
+    estimated_impressions: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9Parameters(TypedDict, total=False):
+    time_unit: Required[Literal['hour', 'day', 'week', 'month']]
+    min_duration: NotRequired[builtins.int]
+    max_duration: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant1 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant2 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant3 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant4 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant5 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6]]
+    metrics: Required[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemOutcomeMeasurementWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItem(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendor]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemCancellationPolicyNoticePeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant1ProductsItemCancellationPolicyCancellationFee(TypedDict, total=False):
+    type: Required[Literal['percent_remaining', 'full_commitment', 'fixed_fee', 'none']]
+    rate: NotRequired[builtins.float]
+    amount: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemAllowedActionsItemSla(TypedDict, total=False):
+    response_max: NotRequired[builtins.str]
+    completion_max: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendor]
+    metric_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesSupportsGeoBreakdown(TypedDict, total=False):
+    country: NotRequired[builtins.bool]
+    region: NotRequired[builtins.bool]
+    metro: NotRequired[builtins.dict[builtins.str, builtins.bool]]
+    postal_area: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesSupportsGeoBreakdownPostalArea]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesMeasurementWindowsItem(TypedDict, total=False):
+    window_id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    duration_days: Required[builtins.int]
+    expected_availability_days: NotRequired[builtins.int]
+    is_guarantee_basis: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemCreativePolicyProvenanceRequirements(TypedDict, total=False):
+    require_digital_source_type: NotRequired[builtins.bool]
+    require_disclosure_metadata: NotRequired[builtins.bool]
+    require_embedded_provenance: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemCreativePolicyAcceptedVerifiersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+    providers: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemIncludedSignalsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant1AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant2AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant3AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant4AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant5AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingRulesSelectionGroupRulesItem(TypedDict, total=False):
+    selection_group: Required[builtins.str]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendor]
+    metric_id: Required[builtins.str]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementReadinessIssuesItem(TypedDict, total=False):
+    severity: Required[Literal['error', 'warning', 'info']]
+    message: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImage(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImage(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItem(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedSpecificationsItem(TypedDict, total=False):
+    label: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemContentRating(TypedDict, total=False):
+    system: Required[Literal['tv_parental', 'mpaa', 'podcast', 'esrb', 'bbfc', 'fsk', 'acb', 'chvrs', 'csa', 'pegi', 'custom']]
+    rating: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemSpecial(TypedDict, total=False):
+    name: Required[builtins.str]
+    category: NotRequired[Literal['awards', 'championship', 'concert', 'conference', 'election', 'festival', 'gala', 'holiday', 'premiere', 'product_launch', 'reunion', 'tribute']]
+    starts: NotRequired[builtins.str]
+    ends: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemGuestTalentItem(TypedDict, total=False):
+    role: Required[Literal['host', 'guest', 'creator', 'cast', 'narrator', 'producer', 'correspondent', 'commentator', 'analyst']]
+    name: Required[builtins.str]
+    brand_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemAdInventory(TypedDict, total=False):
+    expected_breaks: Required[builtins.int]
+    total_ad_seconds: NotRequired[builtins.int]
+    max_ad_duration_seconds: NotRequired[builtins.int]
+    unplanned_breaks: NotRequired[builtins.bool]
+    supported_formats: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemDeadlines(TypedDict, total=False):
+    booking_deadline: NotRequired[builtins.str]
+    cancellation_deadline: NotRequired[builtins.str]
+    material_deadlines: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemInstallmentsItemDeadlinesMaterialDeadlinesItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemDerivativeOf(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    type: Required[Literal['clip', 'highlight', 'recap', 'trailer', 'bonus']]
+
+class _TasksGetResponseResultVariant1ProductsItemTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    countries: NotRequired[builtins.list[builtins.str]]
+    uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemDaypartTargetsItem(TypedDict, total=False):
+    days: Required[builtins.list[Literal['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']]]
+    start_hour: Required[builtins.int]
+    end_hour: Required[builtins.int]
+    label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecast(TypedDict, total=False):
+    points: Required[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItem]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemInsertionOrderTerms(TypedDict, total=False):
+    advertiser: NotRequired[builtins.str]
+    publisher: NotRequired[builtins.str]
+    total_budget: NotRequired[_TasksGetResponseResultVariant1ProposalsItemInsertionOrderTermsTotalBudget]
+    flight_start: NotRequired[builtins.str]
+    flight_end: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_30', 'net_60', 'net_90', 'prepaid', 'due_on_receipt']]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant1 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant2 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant3 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant4 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant5 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6]]
+    metrics: Required[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItem]]
+
+class _TasksGetResponseResultVariant1ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    card_aspect_ratio: NotRequired[builtins.str]
+    min_cards: NotRequired[builtins.int]
+    max_cards: NotRequired[builtins.int]
+    allowed_card_media_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    allowed_card_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    card_image_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_duration_ms: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    card_headline_max_chars: NotRequired[builtins.int]
+    card_description_max_chars: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    min_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    video_codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'mp3', 'opus', 'pcm']]]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    max_file_size_mb: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    captions: NotRequired[Literal['required', 'recommended', 'not_required']]
+    om_sdk_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    companion_banner_widths: NotRequired[builtins.list[builtins.int]]
+    companion_banner_heights: NotRequired[builtins.list[builtins.int]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+    vpaid_enabled: NotRequired[builtins.bool]
+    vpaid_version: NotRequired[Literal['1.0', '2.0']]
+    simid_supported: NotRequired[builtins.bool]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    skippable_after_ms: NotRequired[builtins.int]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    audio_codecs: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'opus', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+    companion_image_required: NotRequired[builtins.bool]
+    companion_image_aspect_ratio: NotRequired[builtins.str]
+    companion_image_max_file_size_kb: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    daast_version: NotRequired[Literal['1.0', '1.1']]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+    companion_image_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    supported_catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    fanout_mode: NotRequired[Literal['per_item', 'multi_item_in_creative', 'single_item']]
+    required_catalog_fields: NotRequired[builtins.list[builtins.str]]
+    supported_id_types: NotRequired[builtins.list[Literal['asin', 'sku', 'gtin', 'offering_id', 'store_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'program_id', 'destination_id', 'app_id', 'job_id']]]
+    hero_asset_supported: NotRequired[builtins.bool]
+    item_production_model: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    title_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    main_image_sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsMainImageSizesItem]]
+    icon_size: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsIconSize]
+    max_image_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp']]]
+    ssl_required: NotRequired[builtins.bool]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    headlines_min: NotRequired[builtins.int]
+    headlines_max: NotRequired[builtins.int]
+    headline_max_chars: NotRequired[builtins.int]
+    long_headlines_min: NotRequired[builtins.int]
+    long_headlines_max: NotRequired[builtins.int]
+    long_headline_max_chars: NotRequired[builtins.int]
+    descriptions_min: NotRequired[builtins.int]
+    descriptions_max: NotRequired[builtins.int]
+    description_max_chars: NotRequired[builtins.int]
+    images_landscape_min: NotRequired[builtins.int]
+    images_landscape_max: NotRequired[builtins.int]
+    images_landscape_aspect_ratio: NotRequired[builtins.str]
+    images_square_min: NotRequired[builtins.int]
+    images_square_max: NotRequired[builtins.int]
+    images_vertical_min: NotRequired[builtins.int]
+    images_vertical_max: NotRequired[builtins.int]
+    videos_min: NotRequired[builtins.int]
+    videos_max: NotRequired[builtins.int]
+    video_min_duration_ms: NotRequired[builtins.int]
+    video_max_duration_ms: NotRequired[builtins.int]
+    logo_min: NotRequired[builtins.int]
+    logo_max: NotRequired[builtins.int]
+    logo_aspect_ratios: NotRequired[builtins.list[builtins.str]]
+    business_name_max_chars: NotRequired[builtins.int]
+    asset_image_max_file_size_kb: NotRequired[builtins.int]
+    supports_catalog_input: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    output_modality: NotRequired[Literal['text', 'audio', 'card']]
+    max_mention_length_chars: NotRequired[builtins.int]
+    max_mention_duration_ms: NotRequired[builtins.int]
+    supports_offering_reference: NotRequired[builtins.bool]
+    supports_landing_page_url: NotRequired[builtins.bool]
+    tone_constraints: NotRequired[builtins.list[builtins.str]]
+    disclosure_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant13V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant13FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1FormatSchema]
+    format_kind: Required[Literal['image']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2FormatSchema]
+    format_kind: Required[Literal['html5']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3FormatSchema]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3 | _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4FormatSchema]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5FormatSchema]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6FormatSchema]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7FormatSchema]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8FormatSchema]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9FormatSchema]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10FormatSchema]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11FormatSchema]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12FormatSchema]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12Params]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant13V1FormatRefItem]]
+    format_schema: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant13FormatSchema]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5Parameters(TypedDict, total=False):
+    view_threshold: Required[builtins.float | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5ParametersViewThresholdVariant2]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6Parameters(TypedDict, total=False):
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: Required[builtins.str]
+    min_points: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8Parameters(TypedDict, total=False):
+    type: Required[Literal['dooh']]
+    sov_percentage: NotRequired[builtins.float]
+    loop_duration_seconds: NotRequired[builtins.int]
+    min_plays_per_hour: NotRequired[builtins.int]
+    venue_package: NotRequired[builtins.str]
+    duration_hours: NotRequired[builtins.float]
+    daypart: NotRequired[builtins.str]
+    estimated_impressions: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9Parameters(TypedDict, total=False):
+    time_unit: Required[Literal['hour', 'day', 'week', 'month']]
+    min_duration: NotRequired[builtins.int]
+    max_duration: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant2]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant1 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant2 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant3 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant4 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant5 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6]]
+    metrics: Required[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemOutcomeMeasurementWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItem(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendor]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCancellationPolicyNoticePeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCancellationPolicyCancellationFee(TypedDict, total=False):
+    type: Required[Literal['percent_remaining', 'full_commitment', 'fixed_fee', 'none']]
+    rate: NotRequired[builtins.float]
+    amount: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemAllowedActionsItemSla(TypedDict, total=False):
+    response_max: NotRequired[builtins.str]
+    completion_max: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendor]
+    metric_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesSupportsGeoBreakdown(TypedDict, total=False):
+    country: NotRequired[builtins.bool]
+    region: NotRequired[builtins.bool]
+    metro: NotRequired[builtins.dict[builtins.str, builtins.bool]]
+    postal_area: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesSupportsGeoBreakdownPostalArea]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesMeasurementWindowsItem(TypedDict, total=False):
+    window_id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    duration_days: Required[builtins.int]
+    expected_availability_days: NotRequired[builtins.int]
+    is_guarantee_basis: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCreativePolicyProvenanceRequirements(TypedDict, total=False):
+    require_digital_source_type: NotRequired[builtins.bool]
+    require_disclosure_metadata: NotRequired[builtins.bool]
+    require_embedded_provenance: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemCreativePolicyAcceptedVerifiersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+    providers: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemIncludedSignalsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant1AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant2AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant3AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant4AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant5AppliesToOutputFormatIdsItem]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingRulesSelectionGroupRulesItem(TypedDict, total=False):
+    selection_group: Required[builtins.str]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendor]
+    metric_id: Required[builtins.str]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementReadinessIssuesItem(TypedDict, total=False):
+    severity: Required[Literal['error', 'warning', 'info']]
+    message: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImage(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImage(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItem(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedSpecificationsItem(TypedDict, total=False):
+    label: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemContentRating(TypedDict, total=False):
+    system: Required[Literal['tv_parental', 'mpaa', 'podcast', 'esrb', 'bbfc', 'fsk', 'acb', 'chvrs', 'csa', 'pegi', 'custom']]
+    rating: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemSpecial(TypedDict, total=False):
+    name: Required[builtins.str]
+    category: NotRequired[Literal['awards', 'championship', 'concert', 'conference', 'election', 'festival', 'gala', 'holiday', 'premiere', 'product_launch', 'reunion', 'tribute']]
+    starts: NotRequired[builtins.str]
+    ends: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemGuestTalentItem(TypedDict, total=False):
+    role: Required[Literal['host', 'guest', 'creator', 'cast', 'narrator', 'producer', 'correspondent', 'commentator', 'analyst']]
+    name: Required[builtins.str]
+    brand_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemAdInventory(TypedDict, total=False):
+    expected_breaks: Required[builtins.int]
+    total_ad_seconds: NotRequired[builtins.int]
+    max_ad_duration_seconds: NotRequired[builtins.int]
+    unplanned_breaks: NotRequired[builtins.bool]
+    supported_formats: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemDeadlines(TypedDict, total=False):
+    booking_deadline: NotRequired[builtins.str]
+    cancellation_deadline: NotRequired[builtins.str]
+    material_deadlines: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemDeadlinesMaterialDeadlinesItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemDerivativeOf(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    type: Required[Literal['clip', 'highlight', 'recap', 'trailer', 'bonus']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    countries: NotRequired[builtins.list[builtins.str]]
+    uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+
+class _TasksGetResponseResultVariant4ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant5AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant5SignalsItemTaxonomyValuesItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    path: NotRequired[builtins.str]
+    modifiers: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant5SignalsItemTaxonomyValueMappingsItem(TypedDict, total=False):
+    value: Required[builtins.str]
+    taxonomy_value_id: Required[builtins.str]
+    path: NotRequired[builtins.str]
+    modifiers: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant5SignalsItemModelingSeedSource(TypedDict, total=False):
+    type: Required[Literal['first_party_crm', 'panel', 'declared_survey', 'transactional', 'behavioral']]
+    provider_signed: Required[builtins.bool]
+
+class _TasksGetResponseResultVariant5SignalsItemModelingDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemModelingDisclosureJurisdictionsItem]]
+    notes: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemDataSubjectRightsChannelsItem(TypedDict, total=False):
+    rights: Required[builtins.list[Literal['access', 'rectification', 'erasure', 'portability', 'objection']]]
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: Required[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant1 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant2 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant3 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant4 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant5 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6]]
+    metrics: Required[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItem]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastScope(TypedDict, total=False):
+    kind: Required[Literal['inventory', 'product', 'account', 'custom']]
+    label: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    line_item_types: NotRequired[builtins.list[builtins.str]]
+    date_range: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastScopeDateRange]
+
+class _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant1AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant2AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant3AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant4AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant5AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant7ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant8Variant1AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBillingEntityAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBillingEntityContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBillingEntityBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountNotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCatalogsItemFeedFieldMappingsItem(TypedDict, total=False):
+    feed_field: NotRequired[builtins.str]
+    catalog_field: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    value: NotRequired[Any]
+    transform: NotRequired[Literal['date', 'divide', 'boolean', 'split']]
+    format: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    by: NotRequired[builtins.float]
+    separator: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoMetrosExcludeItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasItemVariant1(TypedDict, total=False):
+    country: Required[builtins.str]
+    system: Required[Literal['postal_code', 'zip', 'zip_plus_four', 'outward', 'full', 'fsa', 'plz', 'code_postal', 'postcode', 'cep', 'pin', 'custom', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasItemVariant2(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant1(TypedDict, total=False):
+    country: Required[builtins.str]
+    system: Required[Literal['postal_code', 'zip', 'zip_plus_four', 'outward', 'full', 'fsa', 'plz', 'code_postal', 'postcode', 'cep', 'pin', 'custom', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant2(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayDaypartTargetsItem(TypedDict, total=False):
+    days: Required[builtins.list[Literal['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']]]
+    start_hour: Required[builtins.int]
+    end_hour: Required[builtins.int]
+    label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroups(TypedDict, total=False):
+    operator: Required[Literal['all']]
+    groups: Required[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayFrequencyCap(TypedDict, total=False):
+    suppress: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayFrequencyCapSuppress]
+    suppress_minutes: NotRequired[builtins.float]
+    max_impressions: NotRequired[builtins.int]
+    per: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    window: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayFrequencyCapWindow]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayPropertyList(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayCollectionList(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayCollectionListExclude(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayAgeRestriction(TypedDict, total=False):
+    min: Required[builtins.int]
+    verification_required: NotRequired[builtins.bool]
+    accepted_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayStoreCatchmentsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    store_ids: NotRequired[builtins.list[builtins.str]]
+    catchment_ids: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3Radius]
+    geometry: Required[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayKeywordTargetsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayNegativeKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendor]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant1QualifierAttributionWindow]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2Vendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCreativeAssignmentsItemPlacementRefsItem(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3Vendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryFrequencyCapSuppress(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryFrequencyCapWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant2AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant8Variant2ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant8Variant3AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant8Variant3ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant10ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant11ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant12Variant1AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCatalogsItemFeedFieldMappingsItem(TypedDict, total=False):
+    feed_field: NotRequired[builtins.str]
+    catalog_field: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    value: NotRequired[Any]
+    transform: NotRequired[Literal['date', 'divide', 'boolean', 'split']]
+    format: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    by: NotRequired[builtins.float]
+    separator: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoMetrosExcludeItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasItemVariant1(TypedDict, total=False):
+    country: Required[builtins.str]
+    system: Required[Literal['postal_code', 'zip', 'zip_plus_four', 'outward', 'full', 'fsa', 'plz', 'code_postal', 'postcode', 'cep', 'pin', 'custom', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasItemVariant2(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant1(TypedDict, total=False):
+    country: Required[builtins.str]
+    system: Required[Literal['postal_code', 'zip', 'zip_plus_four', 'outward', 'full', 'fsa', 'plz', 'code_postal', 'postcode', 'cep', 'pin', 'custom', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoPostalAreasExcludeItemVariant2(TypedDict, total=False):
+    system: Required[Literal['us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayDaypartTargetsItem(TypedDict, total=False):
+    days: Required[builtins.list[Literal['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']]]
+    start_hour: Required[builtins.int]
+    end_hour: Required[builtins.int]
+    label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroups(TypedDict, total=False):
+    operator: Required[Literal['all']]
+    groups: Required[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayFrequencyCap(TypedDict, total=False):
+    suppress: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayFrequencyCapSuppress]
+    suppress_minutes: NotRequired[builtins.float]
+    max_impressions: NotRequired[builtins.int]
+    per: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    window: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayFrequencyCapWindow]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayPropertyList(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayCollectionList(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayCollectionListExclude(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayAgeRestriction(TypedDict, total=False):
+    min: Required[builtins.int]
+    verification_required: NotRequired[builtins.bool]
+    accepted_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayStoreCatchmentsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    store_ids: NotRequired[builtins.list[builtins.str]]
+    catchment_ids: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3Radius]
+    geometry: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayKeywordTargetsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayNegativeKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendor]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant1QualifierAttributionWindow]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2Vendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCreativeAssignmentsItemPlacementRefsItem(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3Vendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _TasksGetResponseResultVariant12Variant2AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant12Variant2ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant12Variant3AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant12Variant3ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant15ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsReachWindowPeriod]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendor]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[builtins.float]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[builtins.float]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemReachWindowPeriod]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendor]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[builtins.float]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[builtins.float]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant1AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1RightsItemRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2RightsItemRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant1Embedding]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant2Embedding]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant3Embedding]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1PreviewErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant2AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1RightsItemRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2RightsItemRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemFormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant1Embedding]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant2Embedding]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant3Embedding]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2PreviewErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant3AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemSignalConditionVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1FormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1Brand]
+    rights: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1RightsItem]]
+    industry_identifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1IndustryIdentifiersItem]]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1Provenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2FormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant1 | _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2Brand]
+    rights: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2RightsItem]]
+    industry_identifiers: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2IndustryIdentifiersItem]]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2Provenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemEval(TypedDict, total=False):
+    features: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemEvalFeaturesItem]]
+    ranked_against: NotRequired[builtins.int]
+    calls_used: NotRequired[builtins.int]
+    seconds_used: NotRequired[builtins.float]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemConsumption(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant17Variant3ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant4AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant4EstimatePerLeafItemConsumptionEstimate(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant5AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant5ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant6AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant17Variant6ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant19ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant20ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant21Variant1AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntity(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntityAddress]
+    contacts: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntityContactsItem]]
+    bank: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntityBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountNotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['scheduled', 'final', 'delayed', 'adjusted', 'impairment', 'creative.status_changed', 'creative.purged', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    authentication: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountNotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant21Variant2AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant21Variant2ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant21Variant3AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant21Variant3ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant24ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant25Variant1AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant25Variant1CatalogsItemErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseResultVariant25Variant1CatalogsItemErrorsItemIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponseResultVariant25Variant2AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant25Variant2ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant25Variant3AdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant25Variant3ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant28ErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _SignedResponse2PayloadResponseResultsItemVariant1(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary', 'parent', 'property', 'trademark']]
+    status: Required[Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown']]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    context_note: NotRequired[builtins.str]
+
+class _SignedResponse2PayloadResponseResultsItemVariant2(TypedDict, total=False):
+    error: Required[_ExternalCoreError]
+
+class _ExternalCoreProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreCatalogItemDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCatalogItemDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCreativeDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreKeywordDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreKeywordDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreGeoDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreGeoDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreDownstreamConnectionRequirementResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreForecastRange(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreForecastPointMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreForecastPointViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreSignalCoverageForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreSignalCoverageForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['scalar']]
+    asset_id: Required[builtins.str]
+    catalog_field: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['asset_pool']]
+    asset_id: Required[builtins.str]
+    asset_group_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsMainImageSizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsIconSize(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    card_aspect_ratio: NotRequired[builtins.str]
+    min_cards: NotRequired[builtins.int]
+    max_cards: NotRequired[builtins.int]
+    allowed_card_media_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    allowed_card_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    card_image_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_duration_ms: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    card_headline_max_chars: NotRequired[builtins.int]
+    card_description_max_chars: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    min_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    video_codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'mp3', 'opus', 'pcm']]]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    max_file_size_mb: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    captions: NotRequired[Literal['required', 'recommended', 'not_required']]
+    om_sdk_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    companion_banner_widths: NotRequired[builtins.list[builtins.int]]
+    companion_banner_heights: NotRequired[builtins.list[builtins.int]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+    vpaid_enabled: NotRequired[builtins.bool]
+    vpaid_version: NotRequired[Literal['1.0', '2.0']]
+    simid_supported: NotRequired[builtins.bool]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    skippable_after_ms: NotRequired[builtins.int]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    audio_codecs: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'opus', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+    companion_image_required: NotRequired[builtins.bool]
+    companion_image_aspect_ratio: NotRequired[builtins.str]
+    companion_image_max_file_size_kb: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    daast_version: NotRequired[Literal['1.0', '1.1']]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+    companion_image_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    supported_catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    fanout_mode: NotRequired[Literal['per_item', 'multi_item_in_creative', 'single_item']]
+    required_catalog_fields: NotRequired[builtins.list[builtins.str]]
+    supported_id_types: NotRequired[builtins.list[Literal['asin', 'sku', 'gtin', 'offering_id', 'store_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'program_id', 'destination_id', 'app_id', 'job_id']]]
+    hero_asset_supported: NotRequired[builtins.bool]
+    item_production_model: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    title_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    main_image_sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsMainImageSizesItem]]
+    icon_size: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsIconSize]
+    max_image_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp']]]
+    ssl_required: NotRequired[builtins.bool]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    headlines_min: NotRequired[builtins.int]
+    headlines_max: NotRequired[builtins.int]
+    headline_max_chars: NotRequired[builtins.int]
+    long_headlines_min: NotRequired[builtins.int]
+    long_headlines_max: NotRequired[builtins.int]
+    long_headline_max_chars: NotRequired[builtins.int]
+    descriptions_min: NotRequired[builtins.int]
+    descriptions_max: NotRequired[builtins.int]
+    description_max_chars: NotRequired[builtins.int]
+    images_landscape_min: NotRequired[builtins.int]
+    images_landscape_max: NotRequired[builtins.int]
+    images_landscape_aspect_ratio: NotRequired[builtins.str]
+    images_square_min: NotRequired[builtins.int]
+    images_square_max: NotRequired[builtins.int]
+    images_vertical_min: NotRequired[builtins.int]
+    images_vertical_max: NotRequired[builtins.int]
+    videos_min: NotRequired[builtins.int]
+    videos_max: NotRequired[builtins.int]
+    video_min_duration_ms: NotRequired[builtins.int]
+    video_max_duration_ms: NotRequired[builtins.int]
+    logo_min: NotRequired[builtins.int]
+    logo_max: NotRequired[builtins.int]
+    logo_aspect_ratios: NotRequired[builtins.list[builtins.str]]
+    business_name_max_chars: NotRequired[builtins.int]
+    asset_image_max_file_size_kb: NotRequired[builtins.int]
+    supports_catalog_input: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    output_modality: NotRequired[Literal['text', 'audio', 'card']]
+    max_mention_length_chars: NotRequired[builtins.int]
+    max_mention_duration_ms: NotRequired[builtins.int]
+    supports_offering_reference: NotRequired[builtins.bool]
+    supports_landing_page_url: NotRequired[builtins.bool]
+    tone_constraints: NotRequired[builtins.list[builtins.str]]
+    disclosure_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant13V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant13FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5ParametersViewThresholdVariant2(TypedDict, total=False):
+    duration_seconds: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant2PlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2 | _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsAudienceSize]
+    reach: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsReach]
+    frequency: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsFrequency]
+    impressions: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsImpressions]
+    clicks: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsClicks]
+    spend: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsSpend]
+    views: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsViews]
+    completed_views: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsCompletedViews]
+    grps: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsGrps]
+    engagements: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsEngagements]
+    follows: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsFollows]
+    saves: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsSaves]
+    profile_visits: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsProfileVisits]
+    measured_impressions: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsMeasuredImpressions]
+    downloads: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsDownloads]
+    plays: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsPlays]
+    coverage_rate: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsCoverageRate]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendor]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityMeasurableImpressions]
+    viewable_impressions: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityViewableImpressions]
+    viewable_rate: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityViewedSeconds]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemValue]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesSupportsGeoBreakdownPostalArea(TypedDict, total=False):
+    US: NotRequired[builtins.list[Literal['zip', 'zip_plus_four']]]
+    GB: NotRequired[builtins.list[Literal['outward', 'full']]]
+    CA: NotRequired[builtins.list[Literal['fsa', 'full']]]
+    DE: NotRequired[builtins.list[Literal['plz']]]
+    CH: NotRequired[builtins.list[Literal['plz']]]
+    AT: NotRequired[builtins.list[Literal['plz']]]
+    FR: NotRequired[builtins.list[Literal['code_postal']]]
+    AU: NotRequired[builtins.list[Literal['postcode']]]
+    BR: NotRequired[builtins.list[Literal['cep']]]
+    IN: NotRequired[builtins.list[Literal['pin']]]
+    ZA: NotRequired[builtins.list[Literal['postal_code']]]
+    us_zip: NotRequired[builtins.bool]
+    us_zip_plus_four: NotRequired[builtins.bool]
+    gb_outward: NotRequired[builtins.bool]
+    gb_full: NotRequired[builtins.bool]
+    ca_fsa: NotRequired[builtins.bool]
+    ca_full: NotRequired[builtins.bool]
+    de_plz: NotRequired[builtins.bool]
+    fr_code_postal: NotRequired[builtins.bool]
+    au_postcode: NotRequired[builtins.bool]
+    ch_plz: NotRequired[builtins.bool]
+    at_plz: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant1AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant2AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant3AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant4AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant5AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemSignalTargetingOptionsItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemInstallmentsItemDeadlinesMaterialDeadlinesItem(TypedDict, total=False):
+    stage: Required[builtins.str]
+    due_at: Required[builtins.str]
+    label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant1 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant2 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant3 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant4 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant5 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6]]
+    metrics: Required[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetrics]
+    viewability: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItem]]
+
+class _TasksGetResponseResultVariant1ProposalsItemInsertionOrderTermsTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant2PlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2 | _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsAudienceSize]
+    reach: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsReach]
+    frequency: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsFrequency]
+    impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsImpressions]
+    clicks: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsClicks]
+    spend: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsSpend]
+    views: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsViews]
+    completed_views: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsCompletedViews]
+    grps: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsGrps]
+    engagements: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsEngagements]
+    follows: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsFollows]
+    saves: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsSaves]
+    profile_visits: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsProfileVisits]
+    measured_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsMeasuredImpressions]
+    downloads: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsDownloads]
+    plays: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsPlays]
+    coverage_rate: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsCoverageRate]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendor]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityMeasurableImpressions]
+    viewable_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityViewableImpressions]
+    viewable_rate: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityViewedSeconds]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemValue]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsMainImageSizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsIconSize(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    card_aspect_ratio: NotRequired[builtins.str]
+    min_cards: NotRequired[builtins.int]
+    max_cards: NotRequired[builtins.int]
+    allowed_card_media_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    allowed_card_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    card_image_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_duration_ms: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    card_headline_max_chars: NotRequired[builtins.int]
+    card_description_max_chars: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    min_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    video_codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'mp3', 'opus', 'pcm']]]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    max_file_size_mb: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    captions: NotRequired[Literal['required', 'recommended', 'not_required']]
+    om_sdk_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    companion_banner_widths: NotRequired[builtins.list[builtins.int]]
+    companion_banner_heights: NotRequired[builtins.list[builtins.int]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2']]
+    vpaid_enabled: NotRequired[builtins.bool]
+    vpaid_version: NotRequired[Literal['1.0', '2.0']]
+    simid_supported: NotRequired[builtins.bool]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    skippable_after_ms: NotRequired[builtins.int]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    audio_codecs: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'opus', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+    companion_image_required: NotRequired[builtins.bool]
+    companion_image_aspect_ratio: NotRequired[builtins.str]
+    companion_image_max_file_size_kb: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    daast_version: NotRequired[Literal['1.0', '1.1']]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+    companion_image_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    supported_catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    fanout_mode: NotRequired[Literal['per_item', 'multi_item_in_creative', 'single_item']]
+    required_catalog_fields: NotRequired[builtins.list[builtins.str]]
+    supported_id_types: NotRequired[builtins.list[Literal['asin', 'sku', 'gtin', 'offering_id', 'store_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'program_id', 'destination_id', 'app_id', 'job_id']]]
+    hero_asset_supported: NotRequired[builtins.bool]
+    item_production_model: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    title_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    main_image_sizes: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsMainImageSizesItem]]
+    icon_size: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsIconSize]
+    max_image_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp']]]
+    ssl_required: NotRequired[builtins.bool]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    headlines_min: NotRequired[builtins.int]
+    headlines_max: NotRequired[builtins.int]
+    headline_max_chars: NotRequired[builtins.int]
+    long_headlines_min: NotRequired[builtins.int]
+    long_headlines_max: NotRequired[builtins.int]
+    long_headline_max_chars: NotRequired[builtins.int]
+    descriptions_min: NotRequired[builtins.int]
+    descriptions_max: NotRequired[builtins.int]
+    description_max_chars: NotRequired[builtins.int]
+    images_landscape_min: NotRequired[builtins.int]
+    images_landscape_max: NotRequired[builtins.int]
+    images_landscape_aspect_ratio: NotRequired[builtins.str]
+    images_square_min: NotRequired[builtins.int]
+    images_square_max: NotRequired[builtins.int]
+    images_vertical_min: NotRequired[builtins.int]
+    images_vertical_max: NotRequired[builtins.int]
+    videos_min: NotRequired[builtins.int]
+    videos_max: NotRequired[builtins.int]
+    video_min_duration_ms: NotRequired[builtins.int]
+    video_max_duration_ms: NotRequired[builtins.int]
+    logo_min: NotRequired[builtins.int]
+    logo_max: NotRequired[builtins.int]
+    logo_aspect_ratios: NotRequired[builtins.list[builtins.str]]
+    business_name_max_chars: NotRequired[builtins.int]
+    asset_image_max_file_size_kb: NotRequired[builtins.int]
+    supports_catalog_input: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12Params(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsSlotsItem]]
+    required_connections: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    output_modality: NotRequired[Literal['text', 'audio', 'card']]
+    max_mention_length_chars: NotRequired[builtins.int]
+    max_mention_duration_ms: NotRequired[builtins.int]
+    supports_offering_reference: NotRequired[builtins.bool]
+    supports_landing_page_url: NotRequired[builtins.bool]
+    tone_constraints: NotRequired[builtins.list[builtins.str]]
+    disclosure_required: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant13V1FormatRefItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant13FormatSchema(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant1PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant2PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant3PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant4PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5ParametersViewThresholdVariant2(TypedDict, total=False):
+    duration_seconds: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant5PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant6PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant7PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant8PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPricingOptionsItemVariant9PriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant2PlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2 | _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsAudienceSize]
+    reach: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsReach]
+    frequency: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsFrequency]
+    impressions: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsImpressions]
+    clicks: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsClicks]
+    spend: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsSpend]
+    views: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsViews]
+    completed_views: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsCompletedViews]
+    grps: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsGrps]
+    engagements: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsEngagements]
+    follows: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsFollows]
+    saves: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsSaves]
+    profile_visits: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsProfileVisits]
+    measured_impressions: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsMeasuredImpressions]
+    downloads: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsDownloads]
+    plays: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsPlays]
+    coverage_rate: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsCoverageRate]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendor]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityMeasurableImpressions]
+    viewable_impressions: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityViewableImpressions]
+    viewable_rate: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityViewedSeconds]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemValue]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesSupportsGeoBreakdownPostalArea(TypedDict, total=False):
+    US: NotRequired[builtins.list[Literal['zip', 'zip_plus_four']]]
+    GB: NotRequired[builtins.list[Literal['outward', 'full']]]
+    CA: NotRequired[builtins.list[Literal['fsa', 'full']]]
+    DE: NotRequired[builtins.list[Literal['plz']]]
+    CH: NotRequired[builtins.list[Literal['plz']]]
+    AT: NotRequired[builtins.list[Literal['plz']]]
+    FR: NotRequired[builtins.list[Literal['code_postal']]]
+    AU: NotRequired[builtins.list[Literal['postcode']]]
+    BR: NotRequired[builtins.list[Literal['cep']]]
+    IN: NotRequired[builtins.list[Literal['pin']]]
+    ZA: NotRequired[builtins.list[Literal['postal_code']]]
+    us_zip: NotRequired[builtins.bool]
+    us_zip_plus_four: NotRequired[builtins.bool]
+    gb_outward: NotRequired[builtins.bool]
+    gb_full: NotRequired[builtins.bool]
+    ca_fsa: NotRequired[builtins.bool]
+    ca_full: NotRequired[builtins.bool]
+    de_plz: NotRequired[builtins.bool]
+    fr_code_postal: NotRequired[builtins.bool]
+    au_postcode: NotRequired[builtins.bool]
+    ch_plz: NotRequired[builtins.bool]
+    at_plz: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant1AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant2AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant3AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant4AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant5AppliesToOutputFormatIdsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemSignalTargetingOptionsItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemInstallmentsItemDeadlinesMaterialDeadlinesItem(TypedDict, total=False):
+    stage: Required[builtins.str]
+    due_at: Required[builtins.str]
+    label: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemModelingDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    disclosure_text: NotRequired[builtins.str]
+    disclosure_url: NotRequired[builtins.str]
+    audience: NotRequired[Literal['buyer', 'data_subject', 'regulator', 'public']]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant2PlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6SignalRefVariant1 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6SignalRefVariant2 | _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsAudienceSize]
+    reach: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsReach]
+    frequency: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsFrequency]
+    impressions: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsImpressions]
+    clicks: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsClicks]
+    spend: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsSpend]
+    views: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsViews]
+    completed_views: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsCompletedViews]
+    grps: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsGrps]
+    engagements: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsEngagements]
+    follows: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsFollows]
+    saves: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsSaves]
+    profile_visits: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsProfileVisits]
+    measured_impressions: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsMeasuredImpressions]
+    downloads: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsDownloads]
+    plays: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsPlays]
+    coverage_rate: Required[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsCoverageRate]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendor]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityMeasurableImpressions]
+    viewable_impressions: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityViewableImpressions]
+    viewable_rate: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityViewedSeconds]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemValue]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemMeasurableImpressions]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastScopeDateRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItem(TypedDict, total=False):
+    operator: Required[Literal['any', 'none']]
+    signals: Required[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayFrequencyCapSuppress(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayFrequencyCapWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlayGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant1QualifierAttributionWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItem(TypedDict, total=False):
+    operator: Required[Literal['any', 'none']]
+    signals: Required[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayFrequencyCapSuppress(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayFrequencyCapWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlayGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant1QualifierAttributionWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant1PreviewPreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant2PreviewPreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1FormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1RightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1RightsItemRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1IndustryIdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1Provenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2FormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverride]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2RightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2RightsItemRightsAgent]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    verification_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2IndustryIdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2Provenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemEvalFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    value: Required[builtins.bool | builtins.float | builtins.str]
+    unit: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+    measured_at: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    methodology_version: NotRequired[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    policy_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntityAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntityContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBillingEntityBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountNotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksGetResponseResultVariant25Variant1CatalogsItemErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsMainImageSizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsIconSize(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant2PlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsAudienceSize(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsReach(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsFrequency(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsClicks(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsSpend(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsCompletedViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsGrps(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsEngagements(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsFollows(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsSaves(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsProfileVisits(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsMeasuredImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsDownloads(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsPlays(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityViewableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityViewedSeconds(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemValue(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant2PlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2 | _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsAudienceSize]
+    reach: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsReach]
+    frequency: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsFrequency]
+    impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsImpressions]
+    clicks: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsClicks]
+    spend: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsSpend]
+    views: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsViews]
+    completed_views: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsCompletedViews]
+    grps: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsGrps]
+    engagements: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsEngagements]
+    follows: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsFollows]
+    saves: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsSaves]
+    profile_visits: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsProfileVisits]
+    measured_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsMeasuredImpressions]
+    downloads: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsDownloads]
+    plays: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsPlays]
+    coverage_rate: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsCoverageRate]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendor]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityMeasurableImpressions]
+    viewable_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityViewableImpressions]
+    viewable_rate: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityViewedSeconds]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItem(TypedDict, total=False):
+    vendor: Required[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendor]
+    metric_id: Required[builtins.str]
+    value: Required[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemValue]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant2PlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsAudienceSize(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsReach(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsFrequency(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsClicks(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsSpend(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsCompletedViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsGrps(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsEngagements(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsFollows(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsSaves(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsProfileVisits(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsMeasuredImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsDownloads(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsPlays(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityViewableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityViewedSeconds(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemValue(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4PlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsMainImageSizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsIconSize(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsPlatformExtensionsItem(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItem(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant2PlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsAudienceSize(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsReach(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsFrequency(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsClicks(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsSpend(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsCompletedViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsGrps(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsEngagements(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsFollows(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsSaves(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsProfileVisits(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsMeasuredImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsDownloads(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsPlays(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityViewableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityViewedSeconds(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemValue(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant2PlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsAudienceSize(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsReach(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsFrequency(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsClicks(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsSpend(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsCompletedViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsGrps(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsEngagements(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsFollows(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsSaves(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsProfileVisits(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsMeasuredImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsDownloads(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsPlays(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityViewableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityViewedSeconds(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemValue(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant3]
+    value_type: Required[Literal['binary']]
+    value: Required[Literal[True]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant2]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant3]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant2]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant2 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant3]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant1 | _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant2]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant3]
+    value_type: Required[Literal['binary']]
+    value: Required[Literal[True]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant2]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant3]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant2]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3(TypedDict, total=False):
+    signal_ref: Required[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant2 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant3]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant1 | _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant2]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1ProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2ProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1ProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2ProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1RightsItemRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2RightsItemRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant2PlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsAudienceSize(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsReach(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsFrequency(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsClicks(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsSpend(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsCompletedViews(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsGrps(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsEngagements(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsFollows(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsSaves(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsProfileVisits(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsMeasuredImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsDownloads(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsPlays(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityViewableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityViewedSeconds(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendor(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemValue(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemMeasurableImpressions(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant1ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant2ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant1RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant2RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant3RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant3ParamsVariant4RequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant4ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant5ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant6ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant7ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant8ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant9ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant10ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant11ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPlacementsItemFormatOptionsItemVariant12ParamsRequiredConnectionsItemResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemTargetingOverlaySignalTargetingGroupsGroupsItemSignalsItemVariant3ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardImageProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardImageProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedHeroImageProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemProductCardDetailedCarouselImagesItemProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1ProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2ProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1AccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant1CreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant2CreativeManifestsItemVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    ai_tool: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemDeliveryMeasurementVendorsItemBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemPerformanceStandardsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemCommittedMetricsItemVariant2VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemOptimizationGoalsItemVariant3VendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant21Variant1CreativesItemAccountBrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProductsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant3PartialResultsItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemReportingCapabilitiesVendorMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemVendorMetricOptimizationSupportedMetricsItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant8Variant1PackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant12Variant1AffectedPackagesItemMeasurementTermsBillingMeasurementVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemTotalsVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant16MediaBuyDeliveriesItemByPackageItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant1BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant17Variant3CreativesItemVariantsItemCreativeManifestVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProductsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant3PartialResultsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant5SignalsItemCoverageForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemViewabilityVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksGetResponseResultVariant1ProposalsItemAllocationsItemForecastPointsItemVendorMetricValuesItemVendorBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class AcquireRightsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    pricing_option_id: builtins.str
+    buyer: _ExternalCoreBrandRef
+    account: _AcquireRightsRequestAccountVariant1 | _AcquireRightsRequestAccountVariant2 | None
+    campaign: _AcquireRightsRequestCampaign
+    revocation_webhook: _ExternalCorePushNotificationConfig
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        pricing_option_id: builtins.str,
+        buyer: _ExternalCoreBrandRef,
+        campaign: _AcquireRightsRequestCampaign,
+        revocation_webhook: _ExternalCorePushNotificationConfig,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _AcquireRightsRequestAccountVariant1 | _AcquireRightsRequestAccountVariant2 = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcquireRightsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    rights_id: builtins.str | None
+    rights_status: Literal['acquired'] | Literal['pending_approval'] | Literal['rejected'] | None
+    brand_id: builtins.str | None
+    terms: _ExternalBrandRightsTerms | None
+    generation_credentials: builtins.list[_ExternalCoreGenerationCredential] | None
+    restrictions: builtins.list[builtins.str] | None
+    disclosure: _AcquireRightsResponseDisclosure | None
+    approval_webhook: _ExternalCorePushNotificationConfig | None
+    usage_reporting_url: builtins.str | None
+    rights_constraint: _ExternalCoreRightsConstraint | None
+    ext: builtins.dict[builtins.str, Any] | None
+    detail: builtins.str | None
+    estimated_response_time: builtins.str | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        rights_status: Literal['acquired'],
+        brand_id: builtins.str,
+        terms: _ExternalBrandRightsTerms,
+        generation_credentials: builtins.list[_ExternalCoreGenerationCredential],
+        rights_constraint: _ExternalCoreRightsConstraint,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        restrictions: builtins.list[builtins.str] = ...,
+        disclosure: _AcquireRightsResponseDisclosure = ...,
+        approval_webhook: _ExternalCorePushNotificationConfig = ...,
+        usage_reporting_url: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        rights_status: Literal['pending_approval'],
+        brand_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        detail: builtins.str = ...,
+        estimated_response_time: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        rights_status: Literal['rejected'],
+        brand_id: builtins.str,
+        reason: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ActivateSignalRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    action: Literal['activate', 'deactivate']
+    signal_agent_segment_id: builtins.str
+    destinations: builtins.list[_ActivateSignalRequestDestinationsItemVariant1 | _ActivateSignalRequestDestinationsItemVariant2]
+    pricing_option_id: builtins.str | None
+    governance_context: builtins.str | None
+    account: _ActivateSignalRequestAccountVariant1 | _ActivateSignalRequestAccountVariant2 | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        signal_agent_segment_id: builtins.str,
+        destinations: builtins.list[_ActivateSignalRequestDestinationsItemVariant1 | _ActivateSignalRequestDestinationsItemVariant2],
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        action: Literal['activate', 'deactivate'] = ...,
+        pricing_option_id: builtins.str = ...,
+        governance_context: builtins.str = ...,
+        account: _ActivateSignalRequestAccountVariant1 | _ActivateSignalRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ActivateSignalResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    deployments: builtins.list[_ActivateSignalResponseDeploymentsItemVariant1 | _ActivateSignalResponseDeploymentsItemVariant2] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        deployments: builtins.list[_ActivateSignalResponseDeploymentsItemVariant1 | _ActivateSignalResponseDeploymentsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    message: builtins.str | None
+    creative_manifest: _BuildCreativeRequestCreativeManifestVariant1 | _BuildCreativeRequestCreativeManifestVariant2 | None
+    creative_id: builtins.str | None
+    concept_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    package_id: builtins.str | None
+    target_format_id: _ExternalCoreFormatId | None
+    target_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    transformer_id: builtins.str | None
+    config: builtins.dict[builtins.str, Any] | None
+    refine_from_build_variant_id: builtins.str | None
+    mode: Literal['execute', 'estimate']
+    max_spend: _BuildCreativeRequestMaxSpend | None
+    max_creatives: builtins.int | None
+    signal_conditions: builtins.list[_BuildCreativeRequestSignalConditionsItemVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2 | _BuildCreativeRequestSignalConditionsItemVariant3] | None
+    max_variants: builtins.int
+    variant_axis: _BuildCreativeRequestVariantAxis | None
+    keep_mode: Literal['keep_all', 'keep_one', 'keep_some']
+    selection_strategy: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] | None
+    account: _BuildCreativeRequestAccountVariant1 | _BuildCreativeRequestAccountVariant2 | None
+    brand: _ExternalCoreBrandRef | None
+    quality: Literal['draft', 'production'] | None
+    evaluator: _BuildCreativeRequestEvaluatorVariant1 | _BuildCreativeRequestEvaluatorVariant2 | _BuildCreativeRequestEvaluatorVariant3 | None
+    item_limit: builtins.int | None
+    include_preview: builtins.bool | None
+    preview_inputs: builtins.list[_BuildCreativeRequestPreviewInputsItem] | None
+    preview_quality: Literal['draft', 'production'] | None
+    preview_output_format: Literal['url', 'html']
+    macro_values: builtins.dict[builtins.str, builtins.str] | None
+    idempotency_key: builtins.str
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        message: builtins.str = ...,
+        creative_manifest: _BuildCreativeRequestCreativeManifestVariant1 | _BuildCreativeRequestCreativeManifestVariant2 = ...,
+        creative_id: builtins.str = ...,
+        concept_id: builtins.str = ...,
+        media_buy_id: builtins.str = ...,
+        package_id: builtins.str = ...,
+        target_format_id: _ExternalCoreFormatId = ...,
+        target_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        transformer_id: builtins.str = ...,
+        config: builtins.dict[builtins.str, Any] = ...,
+        refine_from_build_variant_id: builtins.str = ...,
+        mode: Literal['execute', 'estimate'] = ...,
+        max_spend: _BuildCreativeRequestMaxSpend = ...,
+        max_creatives: builtins.int = ...,
+        signal_conditions: builtins.list[_BuildCreativeRequestSignalConditionsItemVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2 | _BuildCreativeRequestSignalConditionsItemVariant3] = ...,
+        max_variants: builtins.int = ...,
+        variant_axis: _BuildCreativeRequestVariantAxis = ...,
+        keep_mode: Literal['keep_all', 'keep_one', 'keep_some'] = ...,
+        selection_strategy: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] = ...,
+        account: _BuildCreativeRequestAccountVariant1 | _BuildCreativeRequestAccountVariant2 = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        quality: Literal['draft', 'production'] = ...,
+        evaluator: _BuildCreativeRequestEvaluatorVariant1 | _BuildCreativeRequestEvaluatorVariant2 | _BuildCreativeRequestEvaluatorVariant3 = ...,
+        item_limit: builtins.int = ...,
+        include_preview: builtins.bool = ...,
+        preview_inputs: builtins.list[_BuildCreativeRequestPreviewInputsItem] = ...,
+        preview_quality: Literal['draft', 'production'] = ...,
+        preview_output_format: Literal['url', 'html'] = ...,
+        macro_values: builtins.dict[builtins.str, builtins.str] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    creative_manifest: _BuildCreativeResponseCreativeManifestVariant1 | _BuildCreativeResponseCreativeManifestVariant2 | None
+    build_variant_id: builtins.str | None
+    recipe_hash: builtins.str | None
+    sandbox: builtins.bool | None
+    expires_at: builtins.str | None
+    preview: _BuildCreativeResponsePreview | _BuildCreativeResponsePreview2 | None
+    preview_error: _ExternalCoreError | None
+    pricing_option_id: builtins.str | None
+    vendor_cost: builtins.float | None
+    currency: builtins.str | None
+    consumption: _ExternalCoreCreativeConsumption | None
+    ext: builtins.dict[builtins.str, Any] | None
+    creative_manifests: builtins.list[_BuildCreativeResponseCreativeManifestsItemVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant2] | None
+    creatives: builtins.list[_BuildCreativeResponseCreativesItem] | None
+    items_total: builtins.int | None
+    items_returned: builtins.int | None
+    leaves_total: builtins.int | None
+    leaves_returned: builtins.int | None
+    keep_mode_applied: Literal['keep_all', 'keep_one', 'keep_some'] | None
+    selection_strategy_applied: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] | None
+    budget_status: Literal['complete', 'capped'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    mode: Literal['estimate'] | None
+    estimate: _BuildCreativeResponseEstimate | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creative_manifest: _BuildCreativeResponseCreativeManifestVariant1 | _BuildCreativeResponseCreativeManifestVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        build_variant_id: builtins.str = ...,
+        recipe_hash: builtins.str = ...,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        preview: _BuildCreativeResponsePreview = ...,
+        preview_error: _ExternalCoreError = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creative_manifests: builtins.list[_BuildCreativeResponseCreativeManifestsItemVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        preview: _BuildCreativeResponsePreview2 = ...,
+        preview_error: _ExternalCoreError = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creatives: builtins.list[_BuildCreativeResponseCreativesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        items_total: builtins.int = ...,
+        items_returned: builtins.int = ...,
+        leaves_total: builtins.int = ...,
+        leaves_returned: builtins.int = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        keep_mode_applied: Literal['keep_all', 'keep_one', 'keep_some'] = ...,
+        selection_strategy_applied: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] = ...,
+        budget_status: Literal['complete', 'capped'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        mode: Literal['estimate'],
+        estimate: _BuildCreativeResponseEstimate,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CalibrateContentRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    artifact: _ExternalContentStandardsArtifact
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        artifact: _ExternalContentStandardsArtifact,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CalibrateContentResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    verdict: Literal['pass', 'fail'] | None
+    confidence: builtins.float | None
+    explanation: builtins.str | None
+    features: builtins.list[_CalibrateContentResponseFeaturesItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        verdict: Literal['pass', 'fail'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        confidence: builtins.float = ...,
+        explanation: builtins.str = ...,
+        features: builtins.list[_CalibrateContentResponseFeaturesItem] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CheckGovernanceRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    plan_id: builtins.str
+    caller: builtins.str
+    purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']
+    tool: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    governance_context: builtins.str | None
+    phase: Literal['purchase', 'modification', 'delivery']
+    planned_delivery: _ExternalCorePlannedDelivery | None
+    delivery_metrics: _CheckGovernanceRequestDeliveryMetrics | None
+    modification_summary: builtins.str | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plan_id: builtins.str,
+        caller: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services'] = ...,
+        tool: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        governance_context: builtins.str = ...,
+        phase: Literal['purchase', 'modification', 'delivery'] = ...,
+        planned_delivery: _ExternalCorePlannedDelivery = ...,
+        delivery_metrics: _CheckGovernanceRequestDeliveryMetrics = ...,
+        modification_summary: builtins.str = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CheckGovernanceResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    check_id: builtins.str
+    verdict: Literal['approved', 'denied', 'conditions']
+    plan_id: builtins.str
+    explanation: builtins.str
+    findings: builtins.list[_CheckGovernanceResponseFindingsItem] | None
+    conditions: builtins.list[_CheckGovernanceResponseConditionsItem] | None
+    expires_at: builtins.str | None
+    next_check: builtins.str | None
+    categories_evaluated: builtins.list[builtins.str] | None
+    policies_evaluated: builtins.list[builtins.str] | None
+    mode: Literal['audit', 'advisory', 'enforce'] | None
+    governance_context: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        check_id: builtins.str,
+        verdict: Literal['approved', 'denied', 'conditions'],
+        plan_id: builtins.str,
+        explanation: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        findings: builtins.list[_CheckGovernanceResponseFindingsItem] = ...,
+        conditions: builtins.list[_CheckGovernanceResponseConditionsItem] = ...,
+        expires_at: builtins.str = ...,
+        next_check: builtins.str = ...,
+        categories_evaluated: builtins.list[builtins.str] = ...,
+        policies_evaluated: builtins.list[builtins.str] = ...,
+        mode: Literal['audit', 'advisory', 'enforce'] = ...,
+        governance_context: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ComplyTestControllerRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    scenario: builtins.str
+    params: _ComplyTestControllerRequestParams | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    account: _ComplyTestControllerRequestAccount
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        scenario: builtins.str,
+        account: _ComplyTestControllerRequestAccount,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        params: _ComplyTestControllerRequestParams = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ComplyTestControllerResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    success: Literal[True] | Literal[False]
+    scenarios: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    previous_state: builtins.str | None
+    current_state: builtins.str | builtins.str | None
+    simulated: builtins.dict[builtins.str, Any] | None
+    cumulative: builtins.dict[builtins.str, Any] | None
+    forced: _ComplyTestControllerResponseForced | None
+    creative_id: builtins.str | None
+    audit_observations: builtins.list[_ExternalCreativeAuditObservation] | None
+    recorded_calls: builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant1 | _ComplyTestControllerResponseRecordedCallsItemVariant2] | None
+    total_count: builtins.int | None
+    truncated: builtins.bool | None
+    since_timestamp: builtins.str | None
+    error: Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'JCS_NON_FINITE_NUMBER', 'INTERNAL_ERROR'] | None
+    error_detail: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        scenarios: builtins.list[builtins.str],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        previous_state: builtins.str,
+        current_state: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        simulated: builtins.dict[builtins.str, Any],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        cumulative: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        forced: _ComplyTestControllerResponseForced,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        creative_id: builtins.str,
+        audit_observations: builtins.list[_ExternalCreativeAuditObservation],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        recorded_calls: builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant1 | _ComplyTestControllerResponseRecordedCallsItemVariant2],
+        total_count: builtins.int,
+        since_timestamp: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        truncated: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[False],
+        error: Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'JCS_NON_FINITE_NUMBER', 'INTERNAL_ERROR'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        error_detail: builtins.str = ...,
+        current_state: builtins.str | None = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ContextMatchRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    type: Literal['context_match_request']
+    protocol_version: builtins.str
+    request_id: builtins.str
+    property_rid: builtins.str
+    property_id: builtins.str | None
+    property_type: Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']
+    placement_id: builtins.str
+    seller_agent_url: builtins.str
+    artifact: _ExternalContentStandardsArtifact | None
+    artifact_refs: builtins.list[_ContextMatchRequestArtifactRefsItem] | None
+    geo: _ContextMatchRequestGeo | None
+    context_signals: _ContextMatchRequestContextSignals | None
+    package_ids: builtins.list[builtins.str] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['context_match_request'],
+        request_id: builtins.str,
+        property_rid: builtins.str,
+        property_type: Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant'],
+        placement_id: builtins.str,
+        seller_agent_url: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        protocol_version: builtins.str = ...,
+        property_id: builtins.str = ...,
+        artifact: _ExternalContentStandardsArtifact = ...,
+        artifact_refs: builtins.list[_ContextMatchRequestArtifactRefsItem] = ...,
+        geo: _ContextMatchRequestGeo = ...,
+        context_signals: _ContextMatchRequestContextSignals = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+    ) -> None: ...
+
+class ContextMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['context_match_response']
+    request_id: builtins.str
+    offers: builtins.list[_ExternalTrustedMatchOffer]
+    cache_ttl: builtins.int | None
+    signals: _ContextMatchResponseSignals | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['context_match_response'],
+        request_id: builtins.str,
+        offers: builtins.list[_ExternalTrustedMatchOffer],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        cache_ttl: builtins.int = ...,
+        signals: _ContextMatchResponseSignals = ...,
+    ) -> None: ...
+
+class CreateCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _CreateCollectionListRequestAccountVariant1 | _CreateCollectionListRequestAccountVariant2 | None
+    name: builtins.str
+    description: builtins.str | None
+    base_collections: builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1 | _CreateCollectionListRequestBaseCollectionsItemVariant2 | _CreateCollectionListRequestBaseCollectionsItemVariant3] | None
+    filters: _ExternalCollectionCollectionListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _CreateCollectionListRequestAccountVariant1 | _CreateCollectionListRequestAccountVariant2 = ...,
+        description: builtins.str = ...,
+        base_collections: builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1 | _CreateCollectionListRequestBaseCollectionsItemVariant2 | _CreateCollectionListRequestBaseCollectionsItemVariant3] = ...,
+        filters: _ExternalCollectionCollectionListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalCollectionCollectionList
+    auth_token: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalCollectionCollectionList,
+        auth_token: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    scope: _CreateContentStandardsRequestScope
+    registry_policy_ids: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _CreateContentStandardsRequestCalibrationExemplars | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        scope: _CreateContentStandardsRequestScope,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        registry_policy_ids: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _CreateContentStandardsRequestCalibrationExemplars = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    standards_id: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    conflicting_standards_id: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        conflicting_standards_id: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    plan_id: builtins.str | None
+    account: _CreateMediaBuyRequestAccountVariant1 | _CreateMediaBuyRequestAccountVariant2
+    proposal_id: builtins.str | None
+    total_budget: _CreateMediaBuyRequestTotalBudget | None
+    packages: builtins.list[_ExternalMediaBuyPackageRequest] | None
+    brand: _ExternalCoreBrandRef
+    advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    io_acceptance: _CreateMediaBuyRequestIoAcceptance | None
+    po_number: builtins.str | None
+    agency_estimate_number: builtins.str | None
+    start_time: Literal['asap'] | builtins.str
+    end_time: builtins.str
+    paused: builtins.bool
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    artifact_webhook: _CreateMediaBuyRequestArtifactWebhook | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _CreateMediaBuyRequestAccountVariant1 | _CreateMediaBuyRequestAccountVariant2,
+        brand: _ExternalCoreBrandRef,
+        start_time: Literal['asap'] | builtins.str,
+        end_time: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        plan_id: builtins.str = ...,
+        proposal_id: builtins.str = ...,
+        total_budget: _CreateMediaBuyRequestTotalBudget = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageRequest] = ...,
+        advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        io_acceptance: _CreateMediaBuyRequestIoAcceptance = ...,
+        po_number: builtins.str = ...,
+        agency_estimate_number: builtins.str = ...,
+        paused: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        artifact_webhook: _CreateMediaBuyRequestArtifactWebhook = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuySubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['completed', 'canceled', 'rejected'] | Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buy_id: builtins.str | None
+    account: _ExternalCoreAccount | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    confirmed_at: builtins.str | None
+    creative_deadline: builtins.str | None
+    revision: builtins.int | None
+    currency: builtins.str | None
+    total_budget: builtins.float | None
+    valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | None
+    available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] | None
+    packages: builtins.list[_ExternalCorePackage] | None
+    planned_delivery: _ExternalCorePlannedDelivery | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed', 'canceled', 'rejected'],
+        media_buy_id: builtins.str,
+        confirmed_at: builtins.str | None,
+        revision: builtins.int,
+        packages: builtins.list[_ExternalCorePackage],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        account: _ExternalCoreAccount = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        creative_deadline: builtins.str = ...,
+        currency: builtins.str = ...,
+        total_budget: builtins.float = ...,
+        valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] = ...,
+        available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] = ...,
+        planned_delivery: _ExternalCorePlannedDelivery = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreatePropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _CreatePropertyListRequestAccountVariant1 | _CreatePropertyListRequestAccountVariant2 | None
+    name: builtins.str
+    description: builtins.str | None
+    base_properties: builtins.list[_CreatePropertyListRequestBasePropertiesItemVariant1 | _CreatePropertyListRequestBasePropertiesItemVariant2 | _CreatePropertyListRequestBasePropertiesItemVariant3] | None
+    filters: _ExternalPropertyPropertyListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _CreatePropertyListRequestAccountVariant1 | _CreatePropertyListRequestAccountVariant2 = ...,
+        description: builtins.str = ...,
+        base_properties: builtins.list[_CreatePropertyListRequestBasePropertiesItemVariant1 | _CreatePropertyListRequestBasePropertiesItemVariant2 | _CreatePropertyListRequestBasePropertiesItemVariant3] = ...,
+        filters: _ExternalPropertyPropertyListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreatePropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalPropertyPropertyList
+    auth_token: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalPropertyPropertyList,
+        auth_token: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreativeApprovalRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    creative_id: builtins.str | None
+    creative_url: builtins.str
+    creative_format: _ExternalCoreFormatId | None
+    description: builtins.str | None
+    metadata: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        creative_url: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        creative_id: builtins.str = ...,
+        creative_format: _ExternalCoreFormatId = ...,
+        description: builtins.str = ...,
+        metadata: builtins.dict[builtins.str, Any] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreativeApprovalResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    approval_status: Literal['approved'] | Literal['rejected'] | Literal['pending_review'] | None
+    rights_id: builtins.str | None
+    creative_id: builtins.str | None
+    creative_url: builtins.str | None
+    approved_at: builtins.str | None
+    conditions: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    estimated_response_time: builtins.str | None
+    status_url: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        approval_status: Literal['approved'],
+        rights_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        approved_at: builtins.str = ...,
+        conditions: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        approval_status: Literal['rejected'],
+        rights_id: builtins.str,
+        reason: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        approval_status: Literal['pending_review'],
+        rights_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        estimated_response_time: builtins.str = ...,
+        status_url: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeleteCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _DeleteCollectionListRequestAccountVariant1 | _DeleteCollectionListRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _DeleteCollectionListRequestAccountVariant1 | _DeleteCollectionListRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeleteCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    deleted: builtins.bool
+    list_id: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        deleted: builtins.bool,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeletePropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _DeletePropertyListRequestAccountVariant1 | _DeletePropertyListRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _DeletePropertyListRequestAccountVariant1 | _DeletePropertyListRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeletePropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    deleted: builtins.bool
+    list_id: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        deleted: builtins.bool,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAccountFinancialsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetAccountFinancialsRequestAccountVariant1 | _GetAccountFinancialsRequestAccountVariant2
+    period: _ExternalCoreDateRange | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _GetAccountFinancialsRequestAccountVariant1 | _GetAccountFinancialsRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        period: _ExternalCoreDateRange = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAccountFinancialsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    account: _GetAccountFinancialsResponseAccountVariant1 | _GetAccountFinancialsResponseAccountVariant2 | None
+    currency: builtins.str | None
+    period: _ExternalCoreDateRange | None
+    timezone: builtins.str | None
+    spend: _GetAccountFinancialsResponseSpend | None
+    credit: _GetAccountFinancialsResponseCredit | None
+    balance: _GetAccountFinancialsResponseBalance | None
+    payment_status: Literal['current', 'past_due', 'suspended'] | None
+    payment_terms: Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] | None
+    invoices: builtins.list[_GetAccountFinancialsResponseInvoicesItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        account: _GetAccountFinancialsResponseAccountVariant1 | _GetAccountFinancialsResponseAccountVariant2,
+        currency: builtins.str,
+        period: _ExternalCoreDateRange,
+        timezone: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        spend: _GetAccountFinancialsResponseSpend = ...,
+        credit: _GetAccountFinancialsResponseCredit = ...,
+        balance: _GetAccountFinancialsResponseBalance = ...,
+        payment_status: Literal['current', 'past_due', 'suspended'] = ...,
+        payment_terms: Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] = ...,
+        invoices: builtins.list[_GetAccountFinancialsResponseInvoicesItem] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAdcpCapabilitiesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAdcpCapabilitiesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    adcp: _GetAdcpCapabilitiesResponseAdcp
+    supported_protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand', 'measurement']]
+    account: _GetAdcpCapabilitiesResponseAccount | None
+    media_buy: _GetAdcpCapabilitiesResponseMediaBuy | None
+    signals: _GetAdcpCapabilitiesResponseSignals | None
+    governance: _GetAdcpCapabilitiesResponseGovernance | None
+    sponsored_intelligence: _GetAdcpCapabilitiesResponseSponsoredIntelligence | None
+    brand: _GetAdcpCapabilitiesResponseBrand | None
+    creative: _GetAdcpCapabilitiesResponseCreative | None
+    request_signing: _GetAdcpCapabilitiesResponseRequestSigning | None
+    webhook_signing: _GetAdcpCapabilitiesResponseWebhookSigning | None
+    identity: _GetAdcpCapabilitiesResponseIdentity | None
+    measurement: _GetAdcpCapabilitiesResponseMeasurement | None
+    compliance_testing: _GetAdcpCapabilitiesResponseComplianceTesting | None
+    specialisms: builtins.list[Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'creative-transformers', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests', 'sponsored-intelligence']] | None
+    extensions_supported: builtins.list[builtins.str] | None
+    experimental_features: builtins.list[builtins.str] | None
+    wholesale_feed_versioning: _GetAdcpCapabilitiesResponseWholesaleFeedVersioning | None
+    last_updated: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    wholesale_feed_webhooks: _GetAdcpCapabilitiesResponseWholesaleFeedWebhooks | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        adcp: _GetAdcpCapabilitiesResponseAdcp,
+        supported_protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand', 'measurement']],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        account: _GetAdcpCapabilitiesResponseAccount = ...,
+        media_buy: _GetAdcpCapabilitiesResponseMediaBuy = ...,
+        signals: _GetAdcpCapabilitiesResponseSignals = ...,
+        governance: _GetAdcpCapabilitiesResponseGovernance = ...,
+        sponsored_intelligence: _GetAdcpCapabilitiesResponseSponsoredIntelligence = ...,
+        brand: _GetAdcpCapabilitiesResponseBrand = ...,
+        creative: _GetAdcpCapabilitiesResponseCreative = ...,
+        request_signing: _GetAdcpCapabilitiesResponseRequestSigning = ...,
+        webhook_signing: _GetAdcpCapabilitiesResponseWebhookSigning = ...,
+        identity: _GetAdcpCapabilitiesResponseIdentity = ...,
+        measurement: _GetAdcpCapabilitiesResponseMeasurement = ...,
+        compliance_testing: _GetAdcpCapabilitiesResponseComplianceTesting = ...,
+        specialisms: builtins.list[Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'creative-transformers', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests', 'sponsored-intelligence']] = ...,
+        extensions_supported: builtins.list[builtins.str] = ...,
+        experimental_features: builtins.list[builtins.str] = ...,
+        wholesale_feed_versioning: _GetAdcpCapabilitiesResponseWholesaleFeedVersioning = ...,
+        last_updated: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        wholesale_feed_webhooks: _GetAdcpCapabilitiesResponseWholesaleFeedWebhooks = ...,
+    ) -> None: ...
+
+class GetBrandIdentityRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    brand_id: builtins.str
+    fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
+    use_case: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        brand_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] = ...,
+        use_case: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetBrandIdentityResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    brand_id: builtins.str | None
+    house: _GetBrandIdentityResponseHouse | None
+    names: builtins.list[builtins.dict[builtins.str, builtins.str]] | None
+    description: builtins.str | None
+    industries: builtins.list[builtins.str] | None
+    keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] | None
+    logos: builtins.list[_GetBrandIdentityResponseLogosItem] | None
+    colors: _GetBrandIdentityResponseColors | None
+    fonts: _GetBrandIdentityResponseFonts | None
+    visual_guidelines: builtins.dict[builtins.str, Any] | None
+    tone: _GetBrandIdentityResponseTone | None
+    tagline: builtins.str | builtins.list[builtins.dict[builtins.str, builtins.str]] | None
+    voice_synthesis: _GetBrandIdentityResponseVoiceSynthesis | None
+    assets: builtins.list[_GetBrandIdentityResponseAssetsItem] | None
+    rights: _GetBrandIdentityResponseRights | None
+    available_fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        brand_id: builtins.str,
+        house: _GetBrandIdentityResponseHouse,
+        names: builtins.list[builtins.dict[builtins.str, builtins.str]],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        description: builtins.str = ...,
+        industries: builtins.list[builtins.str] = ...,
+        keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] = ...,
+        logos: builtins.list[_GetBrandIdentityResponseLogosItem] = ...,
+        colors: _GetBrandIdentityResponseColors = ...,
+        fonts: _GetBrandIdentityResponseFonts = ...,
+        visual_guidelines: builtins.dict[builtins.str, Any] = ...,
+        tone: _GetBrandIdentityResponseTone = ...,
+        tagline: builtins.str | builtins.list[builtins.dict[builtins.str, builtins.str]] = ...,
+        voice_synthesis: _GetBrandIdentityResponseVoiceSynthesis = ...,
+        assets: builtins.list[_GetBrandIdentityResponseAssetsItem] = ...,
+        rights: _GetBrandIdentityResponseRights = ...,
+        available_fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _GetCollectionListRequestAccountVariant1 | _GetCollectionListRequestAccountVariant2 | None
+    resolve: builtins.bool
+    pagination: _GetCollectionListRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetCollectionListRequestAccountVariant1 | _GetCollectionListRequestAccountVariant2 = ...,
+        resolve: builtins.bool = ...,
+        pagination: _GetCollectionListRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalCollectionCollectionList
+    collections: builtins.list[_GetCollectionListResponseCollectionsItem] | None
+    pagination: _ExternalCorePaginationResponse | None
+    resolved_at: builtins.str | None
+    cache_valid_until: builtins.str | None
+    coverage_gaps: builtins.dict[builtins.str, builtins.list[_GetCollectionListResponseCoverageGapsValueItem]] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalCollectionCollectionList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        collections: builtins.list[_GetCollectionListResponseCollectionsItem] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        resolved_at: builtins.str = ...,
+        cache_valid_until: builtins.str = ...,
+        coverage_gaps: builtins.dict[builtins.str, builtins.list[_GetCollectionListResponseCoverageGapsValueItem]] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    standards_id: builtins.str | None
+    name: builtins.str | None
+    countries_all: builtins.list[builtins.str] | None
+    channels_any: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None
+    languages_any: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _GetContentStandardsResponseCalibrationExemplars | None
+    pricing_options: builtins.list[_GetContentStandardsResponsePricingOptionsItemVariant1 | _GetContentStandardsResponsePricingOptionsItemVariant2 | _GetContentStandardsResponsePricingOptionsItemVariant3 | _GetContentStandardsResponsePricingOptionsItemVariant4 | _GetContentStandardsResponsePricingOptionsItemVariant5] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        name: builtins.str = ...,
+        countries_all: builtins.list[builtins.str] = ...,
+        channels_any: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] = ...,
+        languages_any: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _GetContentStandardsResponseCalibrationExemplars = ...,
+        pricing_options: builtins.list[_GetContentStandardsResponsePricingOptionsItemVariant1 | _GetContentStandardsResponsePricingOptionsItemVariant2 | _GetContentStandardsResponsePricingOptionsItemVariant3 | _GetContentStandardsResponsePricingOptionsItemVariant4 | _GetContentStandardsResponsePricingOptionsItemVariant5] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetCreativeDeliveryRequestAccountVariant1 | _GetCreativeDeliveryRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    creative_ids: builtins.list[builtins.str] | None
+    start_date: builtins.str | None
+    end_date: builtins.str | None
+    max_variants: builtins.int | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetCreativeDeliveryRequestAccountVariant1 | _GetCreativeDeliveryRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        creative_ids: builtins.list[builtins.str] = ...,
+        start_date: builtins.str = ...,
+        end_date: builtins.str = ...,
+        max_variants: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    account_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    currency: builtins.str
+    reporting_period: _GetCreativeDeliveryResponseReportingPeriod
+    creatives: builtins.list[_GetCreativeDeliveryResponseCreativesItem]
+    pagination: _GetCreativeDeliveryResponsePagination | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        currency: builtins.str,
+        reporting_period: _GetCreativeDeliveryResponseReportingPeriod,
+        creatives: builtins.list[_GetCreativeDeliveryResponseCreativesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        account_id: builtins.str = ...,
+        media_buy_id: builtins.str = ...,
+        pagination: _GetCreativeDeliveryResponsePagination = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeFeaturesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    creative_manifest: _GetCreativeFeaturesRequestCreativeManifestVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant2
+    feature_ids: builtins.list[builtins.str] | None
+    account: _GetCreativeFeaturesRequestAccountVariant1 | _GetCreativeFeaturesRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        creative_manifest: _GetCreativeFeaturesRequestCreativeManifestVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        feature_ids: builtins.list[builtins.str] = ...,
+        account: _GetCreativeFeaturesRequestAccountVariant1 | _GetCreativeFeaturesRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeFeaturesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_ExternalCreativeCreativeFeatureResult] | None
+    detail_url: builtins.str | None
+    audit_observations: builtins.list[_ExternalCreativeAuditObservation] | None
+    pricing_option_id: builtins.str | None
+    vendor_cost: builtins.float | None
+    currency: builtins.str | None
+    consumption: _ExternalCoreCreativeConsumption | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        results: builtins.list[_ExternalCreativeCreativeFeatureResult],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        detail_url: builtins.str = ...,
+        audit_observations: builtins.list[_ExternalCreativeAuditObservation] = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyArtifactsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuyArtifactsRequestAccountVariant1 | _GetMediaBuyArtifactsRequestAccountVariant2 | None
+    media_buy_id: builtins.str
+    package_ids: builtins.list[builtins.str] | None
+    failures_only: builtins.bool
+    time_range: _GetMediaBuyArtifactsRequestTimeRange | None
+    pagination: _GetMediaBuyArtifactsRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuyArtifactsRequestAccountVariant1 | _GetMediaBuyArtifactsRequestAccountVariant2 = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+        failures_only: builtins.bool = ...,
+        time_range: _GetMediaBuyArtifactsRequestTimeRange = ...,
+        pagination: _GetMediaBuyArtifactsRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyArtifactsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buy_id: builtins.str | None
+    artifacts: builtins.list[_GetMediaBuyArtifactsResponseArtifactsItem] | None
+    collection_info: _GetMediaBuyArtifactsResponseCollectionInfo | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        media_buy_id: builtins.str,
+        artifacts: builtins.list[_GetMediaBuyArtifactsResponseArtifactsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        collection_info: _GetMediaBuyArtifactsResponseCollectionInfo = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuyDeliveryRequestAccountVariant1 | _GetMediaBuyDeliveryRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None
+    start_date: builtins.str | None
+    end_date: builtins.str | None
+    include_package_daily_breakdown: builtins.bool
+    time_granularity: Literal['hourly', 'daily', 'monthly'] | None
+    include_window_breakdown: builtins.bool
+    attribution_window: _GetMediaBuyDeliveryRequestAttributionWindow | None
+    reporting_dimensions: _GetMediaBuyDeliveryRequestReportingDimensions | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuyDeliveryRequestAccountVariant1 | _GetMediaBuyDeliveryRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] = ...,
+        start_date: builtins.str = ...,
+        end_date: builtins.str = ...,
+        include_package_daily_breakdown: builtins.bool = ...,
+        time_granularity: Literal['hourly', 'daily', 'monthly'] = ...,
+        include_window_breakdown: builtins.bool = ...,
+        attribution_window: _GetMediaBuyDeliveryRequestAttributionWindow = ...,
+        reporting_dimensions: _GetMediaBuyDeliveryRequestReportingDimensions = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    notification_type: Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] | None
+    partial_data: builtins.bool | None
+    unavailable_count: builtins.int | None
+    sequence_number: builtins.int | None
+    next_expected_at: builtins.str | None
+    reporting_period: _GetMediaBuyDeliveryResponseReportingPeriod
+    currency: builtins.str
+    attribution_window: _ExternalCoreAttributionWindow | None
+    aggregated_totals: _GetMediaBuyDeliveryResponseAggregatedTotals | None
+    media_buy_deliveries: builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        reporting_period: _GetMediaBuyDeliveryResponseReportingPeriod,
+        currency: builtins.str,
+        media_buy_deliveries: builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        notification_type: Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] = ...,
+        partial_data: builtins.bool = ...,
+        unavailable_count: builtins.int = ...,
+        sequence_number: builtins.int = ...,
+        next_expected_at: builtins.str = ...,
+        attribution_window: _ExternalCoreAttributionWindow = ...,
+        aggregated_totals: _GetMediaBuyDeliveryResponseAggregatedTotals = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuysRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuysRequestAccountVariant1 | _GetMediaBuysRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None
+    include_snapshot: builtins.bool
+    include_history: builtins.int
+    include_webhook_activity: builtins.bool
+    webhook_activity_limit: builtins.int
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuysRequestAccountVariant1 | _GetMediaBuysRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] = ...,
+        include_snapshot: builtins.bool = ...,
+        include_history: builtins.int = ...,
+        include_webhook_activity: builtins.bool = ...,
+        webhook_activity_limit: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuysResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buys: builtins.list[_GetMediaBuysResponseMediaBuysItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        media_buys: builtins.list[_GetMediaBuysResponseMediaBuysItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPlanAuditLogsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    plan_ids: builtins.list[builtins.str] | None
+    portfolio_plan_ids: builtins.list[builtins.str] | None
+    governance_contexts: builtins.list[builtins.str] | None
+    purchase_types: builtins.list[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] | None
+    include_entries: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        plan_ids: builtins.list[builtins.str] = ...,
+        portfolio_plan_ids: builtins.list[builtins.str] = ...,
+        governance_contexts: builtins.list[builtins.str] = ...,
+        purchase_types: builtins.list[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] = ...,
+        include_entries: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPlanAuditLogsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    plans: builtins.list[_GetPlanAuditLogsResponsePlansItem]
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        plans: builtins.list[_GetPlanAuditLogsResponsePlansItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] | None
+    partial_results: builtins.list[_ExternalCoreProduct] | None
+    suggestions: builtins.list[builtins.str] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] = ...,
+        partial_results: builtins.list[_ExternalCoreProduct] = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    buying_mode: Literal['brief', 'wholesale', 'refine']
+    brief: builtins.str | None
+    refine: builtins.list[_GetProductsRequestRefineItemVariant1 | _GetProductsRequestRefineItemVariant2 | _GetProductsRequestRefineItemVariant3] | None
+    brand: _ExternalCoreBrandRef | None
+    catalog: _ExternalCoreCatalog | None
+    account: _GetProductsRequestAccountVariant1 | _GetProductsRequestAccountVariant2 | None
+    preferred_delivery_types: builtins.list[Literal['guaranteed', 'non_guaranteed']] | None
+    filters: _ExternalCoreProductFilters | None
+    property_list: _ExternalCorePropertyListRef | None
+    fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_ids', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'included_signals', 'signal_targeting_allowed', 'signal_targeting_options', 'signal_targeting_rules', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] | None
+    time_budget: _GetProductsRequestTimeBudget | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    pagination: _ExternalCorePaginationRequest | None
+    if_wholesale_feed_version: builtins.str | None
+    if_pricing_version: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    required_policies: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        buying_mode: Literal['brief', 'wholesale', 'refine'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        brief: builtins.str = ...,
+        refine: builtins.list[_GetProductsRequestRefineItemVariant1 | _GetProductsRequestRefineItemVariant2 | _GetProductsRequestRefineItemVariant3] = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        catalog: _ExternalCoreCatalog = ...,
+        account: _GetProductsRequestAccountVariant1 | _GetProductsRequestAccountVariant2 = ...,
+        preferred_delivery_types: builtins.list[Literal['guaranteed', 'non_guaranteed']] = ...,
+        filters: _ExternalCoreProductFilters = ...,
+        property_list: _ExternalCorePropertyListRef = ...,
+        fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_ids', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'included_signals', 'signal_targeting_allowed', 'signal_targeting_options', 'signal_targeting_rules', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] = ...,
+        time_budget: _GetProductsRequestTimeBudget = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        if_wholesale_feed_version: builtins.str = ...,
+        if_pricing_version: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        required_policies: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    estimated_completion: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        estimated_completion: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    products: builtins.list[_ExternalCoreProduct] | None
+    extensions: builtins.dict[builtins.str, Any] | None
+    proposals: builtins.list[_ExternalCoreProposal] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    property_list_applied: builtins.bool | None
+    catalog_applied: builtins.bool | None
+    refinement_applied: builtins.list[_GetProductsResponseRefinementAppliedItemVariant1 | _GetProductsResponseRefinementAppliedItemVariant2 | _GetProductsResponseRefinementAppliedItemVariant3] | None
+    incomplete: builtins.list[_GetProductsResponseIncompleteItem] | None
+    filter_diagnostics: _GetProductsResponseFilterDiagnostics | None
+    pagination: _ExternalCorePaginationResponse | None
+    wholesale_feed_version: builtins.str | None
+    pricing_version: builtins.str | None
+    cache_scope: Literal['public', 'account'] | None
+    unchanged: Literal[True] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        products: builtins.list[_ExternalCoreProduct] = ...,
+        extensions: builtins.dict[builtins.str, Any] = ...,
+        proposals: builtins.list[_ExternalCoreProposal] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        property_list_applied: builtins.bool = ...,
+        catalog_applied: builtins.bool = ...,
+        refinement_applied: builtins.list[_GetProductsResponseRefinementAppliedItemVariant1 | _GetProductsResponseRefinementAppliedItemVariant2 | _GetProductsResponseRefinementAppliedItemVariant3] = ...,
+        incomplete: builtins.list[_GetProductsResponseIncompleteItem] = ...,
+        filter_diagnostics: _GetProductsResponseFilterDiagnostics = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        wholesale_feed_version: builtins.str = ...,
+        pricing_version: builtins.str = ...,
+        cache_scope: Literal['public', 'account'] = ...,
+        unchanged: Literal[True] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _GetPropertyListRequestAccountVariant1 | _GetPropertyListRequestAccountVariant2 | None
+    resolve: builtins.bool
+    pagination: _GetPropertyListRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetPropertyListRequestAccountVariant1 | _GetPropertyListRequestAccountVariant2 = ...,
+        resolve: builtins.bool = ...,
+        pagination: _GetPropertyListRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalPropertyPropertyList
+    identifiers: builtins.list[_ExternalCoreIdentifier] | None
+    pagination: _ExternalCorePaginationResponse | None
+    resolved_at: builtins.str | None
+    cache_valid_until: builtins.str | None
+    coverage_gaps: builtins.dict[builtins.str, builtins.list[_ExternalCoreIdentifier]] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalPropertyPropertyList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        identifiers: builtins.list[_ExternalCoreIdentifier] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        resolved_at: builtins.str = ...,
+        cache_valid_until: builtins.str = ...,
+        coverage_gaps: builtins.dict[builtins.str, builtins.list[_ExternalCoreIdentifier]] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetRightsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    query: builtins.str
+    uses: builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]
+    buyer_brand: _ExternalCoreBrandRef | None
+    countries: builtins.list[builtins.str] | None
+    brand_id: builtins.str | None
+    right_type: Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] | None
+    include_excluded: builtins.bool
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query: builtins.str,
+        uses: builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        buyer_brand: _ExternalCoreBrandRef = ...,
+        countries: builtins.list[builtins.str] = ...,
+        brand_id: builtins.str = ...,
+        right_type: Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] = ...,
+        include_excluded: builtins.bool = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetRightsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    rights: builtins.list[_GetRightsResponseRightsItem] | None
+    excluded: builtins.list[_GetRightsResponseExcludedItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights: builtins.list[_GetRightsResponseRightsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        excluded: builtins.list[_GetRightsResponseExcludedItem] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    discovery_mode: Literal['brief', 'wholesale']
+    account: _GetSignalsRequestAccountVariant1 | _GetSignalsRequestAccountVariant2 | None
+    signal_spec: builtins.str | None
+    signal_refs: builtins.list[_GetSignalsRequestSignalRefsItemVariant1 | _GetSignalsRequestSignalRefsItemVariant2 | _GetSignalsRequestSignalRefsItemVariant3] | None
+    signal_ids: builtins.list[_GetSignalsRequestSignalIdsItemVariant1 | _GetSignalsRequestSignalIdsItemVariant2] | None
+    destinations: builtins.list[_GetSignalsRequestDestinationsItemVariant1 | _GetSignalsRequestDestinationsItemVariant2] | None
+    countries: builtins.list[builtins.str] | None
+    filters: _ExternalCoreSignalFilters | None
+    fields: builtins.list[Literal['signal_ref', 'signal_id', 'signal_agent_segment_id', 'name', 'description', 'value_type', 'categories', 'range', 'signal_type', 'data_provider', 'coverage_percentage', 'deployments', 'pricing_options', 'taxonomy', 'data_sources', 'methodology', 'segmentation_criteria', 'criteria_url', 'refresh_cadence', 'lookback_window', 'onboarder', 'modeling', 'audience_expansion', 'device_expansion', 'countries', 'consent_basis', 'restricted_attributes', 'policy_categories', 'art9_basis', 'data_subject_rights', 'last_updated']] | None
+    max_results: builtins.int | None
+    pagination: _ExternalCorePaginationRequest | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    if_wholesale_feed_version: builtins.str | None
+    if_pricing_version: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        discovery_mode: Literal['brief', 'wholesale'] = ...,
+        account: _GetSignalsRequestAccountVariant1 | _GetSignalsRequestAccountVariant2 = ...,
+        signal_spec: builtins.str = ...,
+        signal_refs: builtins.list[_GetSignalsRequestSignalRefsItemVariant1 | _GetSignalsRequestSignalRefsItemVariant2 | _GetSignalsRequestSignalRefsItemVariant3] = ...,
+        signal_ids: builtins.list[_GetSignalsRequestSignalIdsItemVariant1 | _GetSignalsRequestSignalIdsItemVariant2] = ...,
+        destinations: builtins.list[_GetSignalsRequestDestinationsItemVariant1 | _GetSignalsRequestDestinationsItemVariant2] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        filters: _ExternalCoreSignalFilters = ...,
+        fields: builtins.list[Literal['signal_ref', 'signal_id', 'signal_agent_segment_id', 'name', 'description', 'value_type', 'categories', 'range', 'signal_type', 'data_provider', 'coverage_percentage', 'deployments', 'pricing_options', 'taxonomy', 'data_sources', 'methodology', 'segmentation_criteria', 'criteria_url', 'refresh_cadence', 'lookback_window', 'onboarder', 'modeling', 'audience_expansion', 'device_expansion', 'countries', 'consent_basis', 'restricted_attributes', 'policy_categories', 'art9_basis', 'data_subject_rights', 'last_updated']] = ...,
+        max_results: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        if_wholesale_feed_version: builtins.str = ...,
+        if_pricing_version: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    estimated_completion: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        estimated_completion: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    signals: builtins.list[_GetSignalsResponseSignalsItem] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    incomplete: builtins.list[_GetSignalsResponseIncompleteItem] | None
+    wholesale_feed_version: builtins.str | None
+    pricing_version: builtins.str | None
+    cache_scope: Literal['public', 'account'] | None
+    unchanged: Literal[True] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        signals: builtins.list[_GetSignalsResponseSignalsItem] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        incomplete: builtins.list[_GetSignalsResponseIncompleteItem] = ...,
+        wholesale_feed_version: builtins.str = ...,
+        pricing_version: builtins.str = ...,
+        cache_scope: Literal['public', 'account'] = ...,
+        unchanged: Literal[True] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetTaskStatusRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    task_id: builtins.str
+    account: _GetTaskStatusRequestAccountVariant1 | _GetTaskStatusRequestAccountVariant2 | None
+    include_history: builtins.bool
+    include_result: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetTaskStatusRequestAccountVariant1 | _GetTaskStatusRequestAccountVariant2 = ...,
+        include_history: builtins.bool = ...,
+        include_result: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetTaskStatusResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    task_type: Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']
+    protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']
+    created_at: builtins.str
+    updated_at: builtins.str
+    completed_at: builtins.str | None
+    has_webhook: builtins.bool | None
+    progress: _GetTaskStatusResponseProgress | None
+    error: _GetTaskStatusResponseError | None
+    history: builtins.list[_GetTaskStatusResponseHistoryItem] | None
+    result: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        task_type: Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights'],
+        protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement'],
+        created_at: builtins.str,
+        updated_at: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        completed_at: builtins.str = ...,
+        has_webhook: builtins.bool = ...,
+        progress: _GetTaskStatusResponseProgress = ...,
+        error: _GetTaskStatusResponseError = ...,
+        history: builtins.list[_GetTaskStatusResponseHistoryItem] = ...,
+        result: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class IdentityMatchRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    type: Literal['identity_match_request']
+    protocol_version: builtins.str
+    request_id: builtins.str
+    seller_agent_url: builtins.str
+    identities: builtins.list[_IdentityMatchRequestIdentitiesItem]
+    consent: _IdentityMatchRequestConsent | None
+    package_ids: builtins.list[builtins.str] | None
+    country: builtins.str | None
+    sealed_credentials: builtins.list[_IdentityMatchRequestSealedCredentialsItem] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['identity_match_request'],
+        request_id: builtins.str,
+        seller_agent_url: builtins.str,
+        identities: builtins.list[_IdentityMatchRequestIdentitiesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        protocol_version: builtins.str = ...,
+        consent: _IdentityMatchRequestConsent = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+        country: builtins.str = ...,
+        sealed_credentials: builtins.list[_IdentityMatchRequestSealedCredentialsItem] = ...,
+    ) -> None: ...
+
+class IdentityMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['identity_match_response']
+    request_id: builtins.str
+    eligible_package_ids: builtins.list[builtins.str]
+    serve_window_sec: builtins.int
+    tmpx: builtins.str | None
+    tmpx_providers: builtins.dict[builtins.str, _IdentityMatchResponseTmpxProvidersValue] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['identity_match_response'],
+        request_id: builtins.str,
+        eligible_package_ids: builtins.list[builtins.str],
+        serve_window_sec: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        tmpx: builtins.str = ...,
+        tmpx_providers: builtins.dict[builtins.str, _IdentityMatchResponseTmpxProvidersValue] = ...,
+    ) -> None: ...
+
+class ListAccountsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListAccountsRequestAccountVariant1 | _ListAccountsRequestAccountVariant2 | None
+    status: Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] | None
+    pagination: _ExternalCorePaginationRequest | None
+    sandbox: builtins.bool | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListAccountsRequestAccountVariant1 | _ListAccountsRequestAccountVariant2 = ...,
+        status: Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        sandbox: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListAccountsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    accounts: builtins.list[_ExternalCoreAccountWithAuthorization]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accounts: builtins.list[_ExternalCoreAccountWithAuthorization],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCollectionListsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListCollectionListsRequestAccountVariant1 | _ListCollectionListsRequestAccountVariant2 | None
+    name_contains: builtins.str | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListCollectionListsRequestAccountVariant1 | _ListCollectionListsRequestAccountVariant2 = ...,
+        name_contains: builtins.str = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCollectionListsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    lists: builtins.list[_ExternalCollectionCollectionList]
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        lists: builtins.list[_ExternalCollectionCollectionList],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    channels: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None
+    languages: builtins.list[builtins.str] | None
+    countries: builtins.list[builtins.str] | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        channels: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] = ...,
+        languages: builtins.list[builtins.str] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    standards: builtins.list[_ExternalContentStandardsContentStandards] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        standards: builtins.list[_ExternalContentStandardsContentStandards],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativeFormatsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    format_ids: builtins.list[_ExternalCoreFormatId] | None
+    type: Literal['audio', 'video', 'display', 'dooh'] | None
+    asset_types: builtins.list[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']] | None
+    max_width: builtins.int | None
+    max_height: builtins.int | None
+    min_width: builtins.int | None
+    min_height: builtins.int | None
+    is_responsive: builtins.bool | None
+    name_search: builtins.str | None
+    wcag_level: Literal['A', 'AA', 'AAA'] | None
+    disclosure_positions: builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] | None
+    disclosure_persistence: builtins.list[Literal['continuous', 'initial', 'flexible']] | None
+    output_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    input_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    include_pricing: builtins.bool
+    account: _ListCreativeFormatsRequestAccountVariant1 | _ListCreativeFormatsRequestAccountVariant2 | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        type: Literal['audio', 'video', 'display', 'dooh'] = ...,
+        asset_types: builtins.list[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']] = ...,
+        max_width: builtins.int = ...,
+        max_height: builtins.int = ...,
+        min_width: builtins.int = ...,
+        min_height: builtins.int = ...,
+        is_responsive: builtins.bool = ...,
+        name_search: builtins.str = ...,
+        wcag_level: Literal['A', 'AA', 'AAA'] = ...,
+        disclosure_positions: builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] = ...,
+        disclosure_persistence: builtins.list[Literal['continuous', 'initial', 'flexible']] = ...,
+        output_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        input_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        include_pricing: builtins.bool = ...,
+        account: _ListCreativeFormatsRequestAccountVariant1 | _ListCreativeFormatsRequestAccountVariant2 = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativeFormatsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    formats: builtins.list[_ExternalCoreFormat]
+    creative_agents: builtins.list[_ListCreativeFormatsResponseCreativeAgentsItem] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        formats: builtins.list[_ExternalCoreFormat],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_agents: builtins.list[_ListCreativeFormatsResponseCreativeAgentsItem] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    filters: _ExternalCoreCreativeFilters | None
+    sort: _ListCreativesRequestSort | None
+    pagination: _ExternalCorePaginationRequest | None
+    include_assignments: builtins.bool
+    include_snapshot: builtins.bool
+    include_items: builtins.bool
+    include_variables: builtins.bool
+    include_pricing: builtins.bool
+    include_purged: builtins.bool
+    include_webhook_activity: builtins.bool
+    webhook_activity_limit: builtins.int
+    account: _ListCreativesRequestAccountVariant1 | _ListCreativesRequestAccountVariant2 | None
+    fields: builtins.list[Literal['creative_id', 'name', 'format_id', 'status', 'created_date', 'updated_date', 'tags', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        filters: _ExternalCoreCreativeFilters = ...,
+        sort: _ListCreativesRequestSort = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        include_assignments: builtins.bool = ...,
+        include_snapshot: builtins.bool = ...,
+        include_items: builtins.bool = ...,
+        include_variables: builtins.bool = ...,
+        include_pricing: builtins.bool = ...,
+        include_purged: builtins.bool = ...,
+        include_webhook_activity: builtins.bool = ...,
+        webhook_activity_limit: builtins.int = ...,
+        account: _ListCreativesRequestAccountVariant1 | _ListCreativesRequestAccountVariant2 = ...,
+        fields: builtins.list[Literal['creative_id', 'name', 'format_id', 'status', 'created_date', 'updated_date', 'tags', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    query_summary: _ListCreativesResponseQuerySummary
+    pagination: _ExternalCorePaginationResponse
+    creatives: builtins.list[_ListCreativesResponseCreativesItemVariant1 | _ListCreativesResponseCreativesItemVariant2]
+    format_summary: builtins.dict[builtins.str, Any] | None
+    status_summary: _ListCreativesResponseStatusSummary | None
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        query_summary: _ListCreativesResponseQuerySummary,
+        pagination: _ExternalCorePaginationResponse,
+        creatives: builtins.list[_ListCreativesResponseCreativesItemVariant1 | _ListCreativesResponseCreativesItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        format_summary: builtins.dict[builtins.str, Any] = ...,
+        status_summary: _ListCreativesResponseStatusSummary = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListPropertyListsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListPropertyListsRequestAccountVariant1 | _ListPropertyListsRequestAccountVariant2 | None
+    name_contains: builtins.str | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListPropertyListsRequestAccountVariant1 | _ListPropertyListsRequestAccountVariant2 = ...,
+        name_contains: builtins.str = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListPropertyListsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    lists: builtins.list[_ExternalPropertyPropertyList]
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        lists: builtins.list[_ExternalPropertyPropertyList],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTasksRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListTasksRequestAccountVariant1 | _ListTasksRequestAccountVariant2 | None
+    filters: _ListTasksRequestFilters | None
+    sort: _ListTasksRequestSort | None
+    pagination: _ExternalCorePaginationRequest | None
+    include_history: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListTasksRequestAccountVariant1 | _ListTasksRequestAccountVariant2 = ...,
+        filters: _ListTasksRequestFilters = ...,
+        sort: _ListTasksRequestSort = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        include_history: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTasksResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    query_summary: _ListTasksResponseQuerySummary
+    tasks: builtins.list[_ListTasksResponseTasksItem]
+    pagination: _ExternalCorePaginationResponse
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        query_summary: _ListTasksResponseQuerySummary,
+        tasks: builtins.list[_ListTasksResponseTasksItem],
+        pagination: _ExternalCorePaginationResponse,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTransformersRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    transformer_ids: builtins.list[builtins.str] | None
+    input_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    output_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    name_search: builtins.str | None
+    brief: builtins.str | None
+    expand_params: builtins.list[builtins.str] | None
+    expand_pagination: builtins.list[_ListTransformersRequestExpandPaginationItem] | None
+    include_pricing: builtins.bool
+    account: _ListTransformersRequestAccountVariant1 | _ListTransformersRequestAccountVariant2 | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        transformer_ids: builtins.list[builtins.str] = ...,
+        input_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        output_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        name_search: builtins.str = ...,
+        brief: builtins.str = ...,
+        expand_params: builtins.list[builtins.str] = ...,
+        expand_pagination: builtins.list[_ListTransformersRequestExpandPaginationItem] = ...,
+        include_pricing: builtins.bool = ...,
+        account: _ListTransformersRequestAccountVariant1 | _ListTransformersRequestAccountVariant2 = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTransformersResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    transformers: builtins.list[_ExternalCoreTransformer]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        transformers: builtins.list[_ExternalCoreTransformer],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class LogEventRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    event_source_id: builtins.str
+    test_event_code: builtins.str | None
+    events: builtins.list[_ExternalCoreEvent]
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        event_source_id: builtins.str,
+        events: builtins.list[_ExternalCoreEvent],
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        test_event_code: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class LogEventResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    events_received: builtins.int | None
+    events_processed: builtins.int | None
+    partial_failures: builtins.list[_LogEventResponsePartialFailuresItem] | None
+    warnings: builtins.list[builtins.str] | None
+    match_quality: builtins.float | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        events_received: builtins.int,
+        events_processed: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        partial_failures: builtins.list[_LogEventResponsePartialFailuresItem] = ...,
+        warnings: builtins.list[builtins.str] = ...,
+        match_quality: builtins.float = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PackageRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    product_id: builtins.str
+    format_ids: builtins.list[_ExternalCoreFormatId] | None
+    format_option_refs: builtins.list[_PackageRequestFormatOptionRefsItemVariant1 | _PackageRequestFormatOptionRefsItemVariant2] | None
+    format_kind: Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom'] | None
+    params: builtins.dict[builtins.str, Any] | None
+    budget: builtins.float
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    pricing_option_id: builtins.str
+    bid_price: builtins.float | None
+    impressions: builtins.float | None
+    start_time: builtins.str | None
+    end_time: builtins.str | None
+    paused: builtins.bool
+    catalogs: builtins.list[_ExternalCoreCatalog] | None
+    optimization_goals: builtins.list[_PackageRequestOptimizationGoalsItemVariant1 | _PackageRequestOptimizationGoalsItemVariant2 | _PackageRequestOptimizationGoalsItemVariant3] | None
+    targeting_overlay: _ExternalCoreTargeting | None
+    measurement_terms: _ExternalCoreMeasurementTerms | None
+    performance_standards: builtins.list[_ExternalCorePerformanceStandard] | None
+    committed_metrics: builtins.list[_PackageRequestCommittedMetricsItemVariant1 | _PackageRequestCommittedMetricsItemVariant2] | None
+    creative_assignments: builtins.list[_ExternalCoreCreativeAssignment] | None
+    creatives: builtins.list[_PackageRequestCreativesItemVariant1 | _PackageRequestCreativesItemVariant2] | None
+    agency_estimate_number: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        product_id: builtins.str,
+        budget: builtins.float,
+        pricing_option_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        format_option_refs: builtins.list[_PackageRequestFormatOptionRefsItemVariant1 | _PackageRequestFormatOptionRefsItemVariant2] = ...,
+        format_kind: Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom'] = ...,
+        params: builtins.dict[builtins.str, Any] = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bid_price: builtins.float = ...,
+        impressions: builtins.float = ...,
+        start_time: builtins.str = ...,
+        end_time: builtins.str = ...,
+        paused: builtins.bool = ...,
+        catalogs: builtins.list[_ExternalCoreCatalog] = ...,
+        optimization_goals: builtins.list[_PackageRequestOptimizationGoalsItemVariant1 | _PackageRequestOptimizationGoalsItemVariant2 | _PackageRequestOptimizationGoalsItemVariant3] = ...,
+        targeting_overlay: _ExternalCoreTargeting = ...,
+        measurement_terms: _ExternalCoreMeasurementTerms = ...,
+        performance_standards: builtins.list[_ExternalCorePerformanceStandard] = ...,
+        committed_metrics: builtins.list[_PackageRequestCommittedMetricsItemVariant1 | _PackageRequestCommittedMetricsItemVariant2] = ...,
+        creative_assignments: builtins.list[_ExternalCoreCreativeAssignment] = ...,
+        creatives: builtins.list[_PackageRequestCreativesItemVariant1 | _PackageRequestCreativesItemVariant2] = ...,
+        agency_estimate_number: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PreviewCreativeRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    request_type: Literal['single', 'batch', 'variant']
+    creative_manifest: _PreviewCreativeRequestCreativeManifestVariant1 | _PreviewCreativeRequestCreativeManifestVariant2 | None
+    format_id: _ExternalCoreFormatId | None
+    inputs: builtins.list[_PreviewCreativeRequestInputsItem] | None
+    template_id: builtins.str | None
+    quality: Literal['draft', 'production'] | None
+    output_format: Literal['url', 'html']
+    item_limit: builtins.int | None
+    requests: builtins.list[_PreviewCreativeRequestRequestsItem] | None
+    variant_id: builtins.str | None
+    creative_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        request_type: Literal['single', 'batch', 'variant'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        creative_manifest: _PreviewCreativeRequestCreativeManifestVariant1 | _PreviewCreativeRequestCreativeManifestVariant2 = ...,
+        format_id: _ExternalCoreFormatId = ...,
+        inputs: builtins.list[_PreviewCreativeRequestInputsItem] = ...,
+        template_id: builtins.str = ...,
+        quality: Literal['draft', 'production'] = ...,
+        output_format: Literal['url', 'html'] = ...,
+        item_limit: builtins.int = ...,
+        requests: builtins.list[_PreviewCreativeRequestRequestsItem] = ...,
+        variant_id: builtins.str = ...,
+        creative_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PreviewCreativeResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    response_type: Literal['single'] | Literal['batch'] | Literal['variant']
+    previews: builtins.list[_PreviewCreativeResponsePreviewsItem] | builtins.list[_PreviewCreativeResponsePreviewsItem2] | None
+    interactive_url: builtins.str | None
+    expires_at: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_PreviewCreativeResponseResultsItemVariant1 | _PreviewCreativeResponseResultsItemVariant2] | None
+    variant_id: builtins.str | None
+    creative_id: builtins.str | None
+    manifest: _PreviewCreativeResponseManifestVariant1 | _PreviewCreativeResponseManifestVariant2 | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        response_type: Literal['single'],
+        previews: builtins.list[_PreviewCreativeResponsePreviewsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        interactive_url: builtins.str = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        response_type: Literal['batch'],
+        results: builtins.list[_PreviewCreativeResponseResultsItemVariant1 | _PreviewCreativeResponseResultsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        response_type: Literal['variant'],
+        variant_id: builtins.str,
+        previews: builtins.list[_PreviewCreativeResponsePreviewsItem2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        manifest: _PreviewCreativeResponseManifestVariant1 | _PreviewCreativeResponseManifestVariant2 = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProvidePerformanceFeedbackRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    media_buy_id: builtins.str
+    idempotency_key: builtins.str
+    measurement_period: _ExternalCoreDatetimeRange
+    performance_index: builtins.float
+    package_id: builtins.str | None
+    creative_id: builtins.str | None
+    metric_type: Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency']
+    feedback_source: Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner']
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        idempotency_key: builtins.str,
+        measurement_period: _ExternalCoreDatetimeRange,
+        performance_index: builtins.float,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        package_id: builtins.str = ...,
+        creative_id: builtins.str = ...,
+        metric_type: Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency'] = ...,
+        feedback_source: Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProvidePerformanceFeedbackResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    success: Literal[True] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProviderIdentityMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['identity_match_response']
+    request_id: builtins.str
+    eligible_package_ids: builtins.list[builtins.str]
+    serve_window_sec: builtins.int
+    tmpx_chunks: builtins.list[_ExternalTrustedMatchTmpxChunk] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['identity_match_response'],
+        request_id: builtins.str,
+        eligible_package_ids: builtins.list[builtins.str],
+        serve_window_sec: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        tmpx_chunks: builtins.list[_ExternalTrustedMatchTmpxChunk] = ...,
+    ) -> None: ...
+
+class ReportPlanOutcomeRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    plan_id: builtins.str
+    check_id: builtins.str | None
+    idempotency_key: builtins.str
+    purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']
+    outcome: Literal['completed', 'failed', 'delivery']
+    seller_response: _ReportPlanOutcomeRequestSellerResponse | None
+    delivery: _ReportPlanOutcomeRequestDelivery | None
+    error: _ReportPlanOutcomeRequestError | None
+    governance_context: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plan_id: builtins.str,
+        idempotency_key: builtins.str,
+        outcome: Literal['completed', 'failed', 'delivery'],
+        governance_context: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        check_id: builtins.str = ...,
+        purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services'] = ...,
+        seller_response: _ReportPlanOutcomeRequestSellerResponse = ...,
+        delivery: _ReportPlanOutcomeRequestDelivery = ...,
+        error: _ReportPlanOutcomeRequestError = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanOutcomeResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    outcome_id: builtins.str
+    outcome_state: Literal['accepted', 'findings']
+    committed_budget: builtins.float | None
+    findings: builtins.list[_ReportPlanOutcomeResponseFindingsItem] | None
+    plan_summary: _ReportPlanOutcomeResponsePlanSummary | None
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        outcome_id: builtins.str,
+        outcome_state: Literal['accepted', 'findings'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        committed_budget: builtins.float = ...,
+        findings: builtins.list[_ReportPlanOutcomeResponseFindingsItem] = ...,
+        plan_summary: _ReportPlanOutcomeResponsePlanSummary = ...,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportUsageRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    reporting_period: _ExternalCoreDatetimeRange
+    usage: builtins.list[_ReportUsageRequestUsageItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        reporting_period: _ExternalCoreDatetimeRange,
+        usage: builtins.list[_ReportUsageRequestUsageItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportUsageResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    accepted: builtins.int
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accepted: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SearchBrandsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    query: builtins.str
+    industries: builtins.list[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']] | None
+    countries: builtins.list[builtins.str] | None
+    buyer_brand: _ExternalCoreBrandRef | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        industries: builtins.list[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        buyer_brand: _ExternalCoreBrandRef = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SearchBrandsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    brands: builtins.list[_SearchBrandResult] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        brands: builtins.list[_SearchBrandResult],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiGetOfferingRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    offering_id: builtins.str
+    intent: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    include_products: builtins.bool
+    product_limit: builtins.int
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        offering_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        intent: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        include_products: builtins.bool = ...,
+        product_limit: builtins.int = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiGetOfferingResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    available: builtins.bool
+    offering_token: builtins.str | None
+    ttl_seconds: builtins.int | None
+    checked_at: builtins.str | None
+    offering: _SiGetOfferingResponseOffering | None
+    matching_products: builtins.list[_SiGetOfferingResponseMatchingProductsItem] | None
+    sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext | None
+    total_matching: builtins.int | None
+    unavailable_reason: builtins.str | None
+    alternative_offering_ids: builtins.list[builtins.str] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        available: builtins.bool,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        offering_token: builtins.str = ...,
+        ttl_seconds: builtins.int = ...,
+        checked_at: builtins.str = ...,
+        offering: _SiGetOfferingResponseOffering = ...,
+        matching_products: builtins.list[_SiGetOfferingResponseMatchingProductsItem] = ...,
+        sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext = ...,
+        total_matching: builtins.int = ...,
+        unavailable_reason: builtins.str = ...,
+        alternative_offering_ids: builtins.list[builtins.str] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiInitiateSessionRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    intent: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    identity: _ExternalSponsoredIntelligenceSiIdentity
+    media_buy_id: builtins.str | None
+    placement: builtins.str | None
+    offering_id: builtins.str | None
+    supported_capabilities: _ExternalSponsoredIntelligenceSiCapabilities | None
+    offering_token: builtins.str | None
+    sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None
+    idempotency_key: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        intent: builtins.str,
+        identity: _ExternalSponsoredIntelligenceSiIdentity,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        media_buy_id: builtins.str = ...,
+        placement: builtins.str = ...,
+        offering_id: builtins.str = ...,
+        supported_capabilities: _ExternalSponsoredIntelligenceSiCapabilities = ...,
+        offering_token: builtins.str = ...,
+        sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiInitiateSessionResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    session_id: builtins.str
+    response: _SiInitiateSessionResponseResponse | None
+    negotiated_capabilities: _ExternalSponsoredIntelligenceSiCapabilities | None
+    sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext | None
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated']
+    session_ttl_seconds: builtins.int | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        session_id: builtins.str,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        response: _SiInitiateSessionResponseResponse = ...,
+        negotiated_capabilities: _ExternalSponsoredIntelligenceSiCapabilities = ...,
+        sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext = ...,
+        session_ttl_seconds: builtins.int = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiSendMessageRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    session_id: builtins.str
+    message: builtins.str | None
+    action_response: _SiSendMessageRequestActionResponse | None
+    sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        session_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        message: builtins.str = ...,
+        action_response: _SiSendMessageRequestActionResponse = ...,
+        sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiSendMessageResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    session_id: builtins.str
+    response: _SiSendMessageResponseResponse | None
+    mcp_resource_uri: builtins.str | None
+    sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext | None
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated']
+    handoff: _SiSendMessageResponseHandoff | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        session_id: builtins.str,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        response: _SiSendMessageResponseResponse = ...,
+        mcp_resource_uri: builtins.str = ...,
+        sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext = ...,
+        handoff: _SiSendMessageResponseHandoff = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiTerminateSessionRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    session_id: builtins.str
+    reason: Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated']
+    termination_context: _SiTerminateSessionRequestTerminationContext | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        session_id: builtins.str,
+        reason: Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        termination_context: _SiTerminateSessionRequestTerminationContext = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiTerminateSessionResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    session_id: builtins.str
+    terminated: builtins.bool
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'] | None
+    acp_handoff: _SiTerminateSessionResponseAcpHandoff | None
+    follow_up: _SiTerminateSessionResponseFollowUp | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        session_id: builtins.str,
+        terminated: builtins.bool,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'] = ...,
+        acp_handoff: _SiTerminateSessionResponseAcpHandoff = ...,
+        follow_up: _SiTerminateSessionResponseFollowUp = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class StaleResponse(VersionedSchemaModel):
+    served_from_cache: Literal[True]
+    cache_age_seconds: builtins.int
+    freshness_target_seconds: builtins.int | None
+    upstream: _StaleResponseUpstream | None
+    original_error: _StaleResponseOriginalError | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        served_from_cache: Literal[True],
+        cache_age_seconds: builtins.int,
+        freshness_target_seconds: builtins.int = ...,
+        upstream: _StaleResponseUpstream = ...,
+        original_error: _StaleResponseOriginalError = ...,
+    ) -> None: ...
+
+class SyncAccountsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    accounts: builtins.list[_SyncAccountsRequestAccountsItemVariant1 | _SyncAccountsRequestAccountsItemVariant2]
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        accounts: builtins.list[_SyncAccountsRequestAccountsItemVariant1 | _SyncAccountsRequestAccountsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAccountsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    accounts: builtins.list[_SyncAccountsResponseAccountsItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accounts: builtins.list[_SyncAccountsResponseAccountsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAudiencesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncAudiencesRequestAccountVariant1 | _SyncAudiencesRequestAccountVariant2
+    audiences: builtins.list[_SyncAudiencesRequestAudiencesItem] | None
+    delete_missing: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncAudiencesRequestAccountVariant1 | _SyncAudiencesRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        audiences: builtins.list[_SyncAudiencesRequestAudiencesItem] = ...,
+        delete_missing: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAudiencesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    audiences: builtins.list[_SyncAudiencesResponseAudiencesItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        audiences: builtins.list[_SyncAudiencesResponseAudiencesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncCatalogsRequestAccountVariant1 | _SyncCatalogsRequestAccountVariant2
+    catalogs: builtins.list[_ExternalCoreCatalog] | None
+    catalog_ids: builtins.list[builtins.str] | None
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    validation_mode: Literal['strict', 'lenient']
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncCatalogsRequestAccountVariant1 | _SyncCatalogsRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        catalogs: builtins.list[_ExternalCoreCatalog] = ...,
+        catalog_ids: builtins.list[builtins.str] = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        validation_mode: Literal['strict', 'lenient'] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    catalogs: builtins.list[_SyncCatalogsResponseCatalogsItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        catalogs: builtins.list[_SyncCatalogsResponseCatalogsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    catalogs_processed: builtins.int | None
+    catalogs_total: builtins.int | None
+    items_processed: builtins.int | None
+    items_total: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        catalogs_processed: builtins.int = ...,
+        catalogs_total: builtins.int = ...,
+        items_processed: builtins.int = ...,
+        items_total: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _SyncCreativesRequestAccountVariant1 | _SyncCreativesRequestAccountVariant2
+    creatives: builtins.list[_SyncCreativesRequestCreativesItemVariant1 | _SyncCreativesRequestCreativesItemVariant2]
+    creative_ids: builtins.list[builtins.str] | None
+    assignments: builtins.list[_SyncCreativesRequestAssignmentsItem] | None
+    idempotency_key: builtins.str
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    validation_mode: Literal['strict', 'lenient']
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _SyncCreativesRequestAccountVariant1 | _SyncCreativesRequestAccountVariant2,
+        creatives: builtins.list[_SyncCreativesRequestCreativesItemVariant1 | _SyncCreativesRequestCreativesItemVariant2],
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        creative_ids: builtins.list[builtins.str] = ...,
+        assignments: builtins.list[_SyncCreativesRequestAssignmentsItem] = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        validation_mode: Literal['strict', 'lenient'] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    creatives: builtins.list[_SyncCreativesResponseCreativesItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creatives: builtins.list[_SyncCreativesResponseCreativesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    creatives_processed: builtins.int | None
+    creatives_total: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        creatives_processed: builtins.int = ...,
+        creatives_total: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncEventSourcesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncEventSourcesRequestAccountVariant1 | _SyncEventSourcesRequestAccountVariant2
+    event_sources: builtins.list[_SyncEventSourcesRequestEventSourcesItem] | None
+    delete_missing: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncEventSourcesRequestAccountVariant1 | _SyncEventSourcesRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        event_sources: builtins.list[_SyncEventSourcesRequestEventSourcesItem] = ...,
+        delete_missing: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncEventSourcesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    event_sources: builtins.list[_SyncEventSourcesResponseEventSourcesItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        event_sources: builtins.list[_SyncEventSourcesResponseEventSourcesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncGovernanceRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    accounts: builtins.list[_SyncGovernanceRequestAccountsItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        accounts: builtins.list[_SyncGovernanceRequestAccountsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncGovernanceResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    accounts: builtins.list[_SyncGovernanceResponseAccountsItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accounts: builtins.list[_SyncGovernanceResponseAccountsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncPlansRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    plans: builtins.list[_SyncPlansRequestPlansItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        plans: builtins.list[_SyncPlansRequestPlansItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncPlansResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    plans: builtins.list[_SyncPlansResponsePlansItem]
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        plans: builtins.list[_SyncPlansResponsePlansItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksGetRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    task_id: builtins.str
+    account: _TasksGetRequestAccountVariant1 | _TasksGetRequestAccountVariant2 | None
+    include_history: builtins.bool
+    include_result: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _TasksGetRequestAccountVariant1 | _TasksGetRequestAccountVariant2 = ...,
+        include_history: builtins.bool = ...,
+        include_result: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksGetResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _TasksGetResponseAdcpError | None
+    push_notification_config: _TasksGetResponsePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    task_type: Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights']
+    protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']
+    created_at: builtins.str
+    updated_at: builtins.str
+    completed_at: builtins.str | None
+    has_webhook: builtins.bool | None
+    progress: _TasksGetResponseProgress | None
+    error: _TasksGetResponseError | None
+    history: builtins.list[_TasksGetResponseHistoryItem] | None
+    result: _TasksGetResponseResultVariant1 | _TasksGetResponseResultVariant2 | _TasksGetResponseResultVariant3 | _TasksGetResponseResultVariant4 | _TasksGetResponseResultVariant5 | _TasksGetResponseResultVariant6 | _TasksGetResponseResultVariant7 | _TasksGetResponseResultVariant8Variant1 | _TasksGetResponseResultVariant8Variant2 | _TasksGetResponseResultVariant8Variant3 | _TasksGetResponseResultVariant9 | _TasksGetResponseResultVariant10 | _TasksGetResponseResultVariant11 | _TasksGetResponseResultVariant12Variant1 | _TasksGetResponseResultVariant12Variant2 | _TasksGetResponseResultVariant12Variant3 | _TasksGetResponseResultVariant13 | _TasksGetResponseResultVariant14 | _TasksGetResponseResultVariant15 | _TasksGetResponseResultVariant16 | _TasksGetResponseResultVariant17Variant1 | _TasksGetResponseResultVariant17Variant2 | _TasksGetResponseResultVariant17Variant3 | _TasksGetResponseResultVariant17Variant4 | _TasksGetResponseResultVariant17Variant5 | _TasksGetResponseResultVariant17Variant6 | _TasksGetResponseResultVariant18 | _TasksGetResponseResultVariant19 | _TasksGetResponseResultVariant20 | _TasksGetResponseResultVariant21Variant1 | _TasksGetResponseResultVariant21Variant2 | _TasksGetResponseResultVariant21Variant3 | _TasksGetResponseResultVariant22 | _TasksGetResponseResultVariant23 | _TasksGetResponseResultVariant24 | _TasksGetResponseResultVariant25Variant1 | _TasksGetResponseResultVariant25Variant2 | _TasksGetResponseResultVariant25Variant3 | _TasksGetResponseResultVariant26 | _TasksGetResponseResultVariant27 | _TasksGetResponseResultVariant28 | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        task_type: Literal['create_media_buy', 'update_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights'],
+        protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement'],
+        created_at: builtins.str,
+        updated_at: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _TasksGetResponseAdcpError = ...,
+        push_notification_config: _TasksGetResponsePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        completed_at: builtins.str = ...,
+        has_webhook: builtins.bool = ...,
+        progress: _TasksGetResponseProgress = ...,
+        error: _TasksGetResponseError = ...,
+        history: builtins.list[_TasksGetResponseHistoryItem] = ...,
+        result: _TasksGetResponseResultVariant1 | _TasksGetResponseResultVariant2 | _TasksGetResponseResultVariant3 | _TasksGetResponseResultVariant4 | _TasksGetResponseResultVariant5 | _TasksGetResponseResultVariant6 | _TasksGetResponseResultVariant7 | _TasksGetResponseResultVariant8Variant1 | _TasksGetResponseResultVariant8Variant2 | _TasksGetResponseResultVariant8Variant3 | _TasksGetResponseResultVariant9 | _TasksGetResponseResultVariant10 | _TasksGetResponseResultVariant11 | _TasksGetResponseResultVariant12Variant1 | _TasksGetResponseResultVariant12Variant2 | _TasksGetResponseResultVariant12Variant3 | _TasksGetResponseResultVariant13 | _TasksGetResponseResultVariant14 | _TasksGetResponseResultVariant15 | _TasksGetResponseResultVariant16 | _TasksGetResponseResultVariant17Variant1 | _TasksGetResponseResultVariant17Variant2 | _TasksGetResponseResultVariant17Variant3 | _TasksGetResponseResultVariant17Variant4 | _TasksGetResponseResultVariant17Variant5 | _TasksGetResponseResultVariant17Variant6 | _TasksGetResponseResultVariant18 | _TasksGetResponseResultVariant19 | _TasksGetResponseResultVariant20 | _TasksGetResponseResultVariant21Variant1 | _TasksGetResponseResultVariant21Variant2 | _TasksGetResponseResultVariant21Variant3 | _TasksGetResponseResultVariant22 | _TasksGetResponseResultVariant23 | _TasksGetResponseResultVariant24 | _TasksGetResponseResultVariant25Variant1 | _TasksGetResponseResultVariant25Variant2 | _TasksGetResponseResultVariant25Variant3 | _TasksGetResponseResultVariant26 | _TasksGetResponseResultVariant27 | _TasksGetResponseResultVariant28 = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _TasksListRequestAccountVariant1 | _TasksListRequestAccountVariant2 | None
+    filters: _TasksListRequestFilters | None
+    sort: _TasksListRequestSort | None
+    pagination: _TasksListRequestPagination | None
+    include_history: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _TasksListRequestAccountVariant1 | _TasksListRequestAccountVariant2 = ...,
+        filters: _TasksListRequestFilters = ...,
+        sort: _TasksListRequestSort = ...,
+        pagination: _TasksListRequestPagination = ...,
+        include_history: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _TasksListResponseAdcpError | None
+    push_notification_config: _TasksListResponsePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    query_summary: _TasksListResponseQuerySummary
+    tasks: builtins.list[_TasksListResponseTasksItem]
+    pagination: _TasksListResponsePagination
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        query_summary: _TasksListResponseQuerySummary,
+        tasks: builtins.list[_TasksListResponseTasksItem],
+        pagination: _TasksListResponsePagination,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _TasksListResponseAdcpError = ...,
+        push_notification_config: _TasksListResponsePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _UpdateCollectionListRequestAccountVariant1 | _UpdateCollectionListRequestAccountVariant2 | None
+    name: builtins.str | None
+    description: builtins.str | None
+    base_collections: builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1 | _UpdateCollectionListRequestBaseCollectionsItemVariant2 | _UpdateCollectionListRequestBaseCollectionsItemVariant3] | None
+    filters: _ExternalCollectionCollectionListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    webhook_url: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdateCollectionListRequestAccountVariant1 | _UpdateCollectionListRequestAccountVariant2 = ...,
+        name: builtins.str = ...,
+        description: builtins.str = ...,
+        base_collections: builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1 | _UpdateCollectionListRequestBaseCollectionsItemVariant2 | _UpdateCollectionListRequestBaseCollectionsItemVariant3] = ...,
+        filters: _ExternalCollectionCollectionListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        webhook_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalCollectionCollectionList
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalCollectionCollectionList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    scope: _UpdateContentStandardsRequestScope | None
+    registry_policy_ids: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _UpdateContentStandardsRequestCalibrationExemplars | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        scope: _UpdateContentStandardsRequestScope = ...,
+        registry_policy_ids: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _UpdateContentStandardsRequestCalibrationExemplars = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    success: Literal[True] | Literal[False]
+    standards_id: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    conflicting_standards_id: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[False],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        conflicting_standards_id: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _UpdateMediaBuyRequestAccountVariant1 | _UpdateMediaBuyRequestAccountVariant2
+    media_buy_id: builtins.str
+    revision: builtins.int | None
+    paused: builtins.bool | None
+    canceled: Literal[True] | None
+    cancellation_reason: builtins.str | None
+    start_time: Literal['asap'] | builtins.str | None
+    end_time: builtins.str | None
+    packages: builtins.list[_ExternalMediaBuyPackageUpdate] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    new_packages: builtins.list[_ExternalMediaBuyPackageRequest] | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _UpdateMediaBuyRequestAccountVariant1 | _UpdateMediaBuyRequestAccountVariant2,
+        media_buy_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        revision: builtins.int = ...,
+        paused: builtins.bool = ...,
+        canceled: Literal[True] = ...,
+        cancellation_reason: builtins.str = ...,
+        start_time: Literal['asap'] | builtins.str = ...,
+        end_time: builtins.str = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageUpdate] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        new_packages: builtins.list[_ExternalMediaBuyPackageRequest] = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuySubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['completed', 'canceled', 'rejected'] | Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buy_id: builtins.str | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    revision: builtins.int | None
+    currency: builtins.str | None
+    total_budget: builtins.float | None
+    implementation_date: builtins.str | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    affected_packages: builtins.list[_ExternalCorePackage] | None
+    valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | None
+    available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed', 'canceled', 'rejected'],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        currency: builtins.str = ...,
+        total_budget: builtins.float = ...,
+        implementation_date: builtins.str | None = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        affected_packages: builtins.list[_ExternalCorePackage] = ...,
+        valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] = ...,
+        available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdatePropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _UpdatePropertyListRequestAccountVariant1 | _UpdatePropertyListRequestAccountVariant2 | None
+    name: builtins.str | None
+    description: builtins.str | None
+    base_properties: builtins.list[_UpdatePropertyListRequestBasePropertiesItemVariant1 | _UpdatePropertyListRequestBasePropertiesItemVariant2 | _UpdatePropertyListRequestBasePropertiesItemVariant3] | None
+    filters: _ExternalPropertyPropertyListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    webhook_url: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdatePropertyListRequestAccountVariant1 | _UpdatePropertyListRequestAccountVariant2 = ...,
+        name: builtins.str = ...,
+        description: builtins.str = ...,
+        base_properties: builtins.list[_UpdatePropertyListRequestBasePropertiesItemVariant1 | _UpdatePropertyListRequestBasePropertiesItemVariant2 | _UpdatePropertyListRequestBasePropertiesItemVariant3] = ...,
+        filters: _ExternalPropertyPropertyListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        webhook_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdatePropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalPropertyPropertyList
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalPropertyPropertyList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateRightsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    account: _UpdateRightsRequestAccountVariant1 | _UpdateRightsRequestAccountVariant2 | None
+    end_date: builtins.str | None
+    impression_cap: builtins.int | None
+    pricing_option_id: builtins.str | None
+    paused: builtins.bool | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdateRightsRequestAccountVariant1 | _UpdateRightsRequestAccountVariant2 = ...,
+        end_date: builtins.str = ...,
+        impression_cap: builtins.int = ...,
+        pricing_option_id: builtins.str = ...,
+        paused: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateRightsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    rights_id: builtins.str | None
+    terms: _ExternalBrandRightsTerms | None
+    generation_credentials: builtins.list[_ExternalCoreGenerationCredential] | None
+    rights_constraint: _ExternalCoreRightsConstraint | None
+    paused: builtins.bool | None
+    implementation_date: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        terms: _ExternalBrandRightsTerms,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        generation_credentials: builtins.list[_ExternalCoreGenerationCredential] = ...,
+        rights_constraint: _ExternalCoreRightsConstraint = ...,
+        paused: builtins.bool = ...,
+        implementation_date: builtins.str | None = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateContentDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    records: builtins.list[_ValidateContentDeliveryRequestRecordsItem]
+    feature_ids: builtins.list[builtins.str] | None
+    include_passed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        records: builtins.list[_ValidateContentDeliveryRequestRecordsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        feature_ids: builtins.list[builtins.str] = ...,
+        include_passed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateContentDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    summary: _ValidateContentDeliveryResponseSummary | None
+    results: builtins.list[_ValidateContentDeliveryResponseResultsItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        summary: _ValidateContentDeliveryResponseSummary,
+        results: builtins.list[_ValidateContentDeliveryResponseResultsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateInputRequest(VersionedSchemaModel):
+    account: _ValidateInputRequestAccountVariant1 | _ValidateInputRequestAccountVariant2 | None
+    brand: _ExternalCoreBrandRef | None
+    manifest: _ValidateInputRequestManifestVariant1 | _ValidateInputRequestManifestVariant2
+    targets: builtins.list[_ValidateInputRequestTargetsItemVariant1 | _ValidateInputRequestTargetsItemVariant2 | _ValidateInputRequestTargetsItemVariant3] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        manifest: _ValidateInputRequestManifestVariant1 | _ValidateInputRequestManifestVariant2,
+        account: _ValidateInputRequestAccountVariant1 | _ValidateInputRequestAccountVariant2 = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        targets: builtins.list[_ValidateInputRequestTargetsItemVariant1 | _ValidateInputRequestTargetsItemVariant2 | _ValidateInputRequestTargetsItemVariant3] = ...,
+    ) -> None: ...
+
+class ValidateInputResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_ExternalCreativeValidateInputResult]
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        results: builtins.list[_ExternalCreativeValidateInputResult],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidatePropertyDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _ValidatePropertyDeliveryRequestAccountVariant1 | _ValidatePropertyDeliveryRequestAccountVariant2 | None
+    records: builtins.list[_ExternalPropertyDeliveryRecord]
+    include_compliant: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        records: builtins.list[_ExternalPropertyDeliveryRecord],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ValidatePropertyDeliveryRequestAccountVariant1 | _ValidatePropertyDeliveryRequestAccountVariant2 = ...,
+        include_compliant: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidatePropertyDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    compliant: builtins.bool | None
+    list_id: builtins.str
+    summary: _ValidatePropertyDeliveryResponseSummary
+    aggregate: _ValidatePropertyDeliveryResponseAggregate | None
+    authorization_summary: _ValidatePropertyDeliveryResponseAuthorizationSummary | None
+    results: builtins.list[_ExternalPropertyValidationResult]
+    validated_at: builtins.str
+    list_resolved_at: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list_id: builtins.str,
+        summary: _ValidatePropertyDeliveryResponseSummary,
+        results: builtins.list[_ExternalPropertyValidationResult],
+        validated_at: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        compliant: builtins.bool = ...,
+        aggregate: _ValidatePropertyDeliveryResponseAggregate = ...,
+        authorization_summary: _ValidatePropertyDeliveryResponseAuthorizationSummary = ...,
+        list_resolved_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    claim_type: Literal['subsidiary'] | Literal['parent'] | Literal['property'] | Literal['trademark']
+    claim: _VerifyBrandClaimRequestClaim | _VerifyBrandClaimRequestClaim2 | _VerifyBrandClaimRequestClaim3 | _VerifyBrandClaimRequestClaim4
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['subsidiary'],
+        claim: _VerifyBrandClaimRequestClaim,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['parent'],
+        claim: _VerifyBrandClaimRequestClaim2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['property'],
+        claim: _VerifyBrandClaimRequestClaim3,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['trademark'],
+        claim: _VerifyBrandClaimRequestClaim4,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    claim_type: Literal['subsidiary', 'parent', 'property', 'trademark'] | None
+    verification_status: Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown'] | None
+    details: builtins.dict[builtins.str, Any] | None
+    context_note: builtins.str | None
+    signed_response: _SignedResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        claim_type: Literal['subsidiary', 'parent', 'property', 'trademark'],
+        verification_status: Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown'],
+        signed_response: _SignedResponse,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        details: builtins.dict[builtins.str, Any] = ...,
+        context_note: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    claims: builtins.list[_VerifyBrandClaimsRequestClaimsItemVariant1 | _VerifyBrandClaimsRequestClaimsItemVariant2 | _VerifyBrandClaimsRequestClaimsItemVariant3 | _VerifyBrandClaimsRequestClaimsItemVariant4]
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claims: builtins.list[_VerifyBrandClaimsRequestClaimsItemVariant1 | _VerifyBrandClaimsRequestClaimsItemVariant2 | _VerifyBrandClaimsRequestClaimsItemVariant3 | _VerifyBrandClaimsRequestClaimsItemVariant4],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_VerifyBrandClaimsResponseResultsItemVariant1 | _VerifyBrandClaimsResponseResultsItemVariant2] | None
+    signed_response: _SignedResponse2 | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        results: builtins.list[_VerifyBrandClaimsResponseResultsItemVariant1 | _VerifyBrandClaimsResponseResultsItemVariant2],
+        signed_response: _SignedResponse2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+__all__ = ['AcquireRightsRequest', 'AcquireRightsResponse', 'ActivateSignalRequest', 'ActivateSignalResponse', 'BuildCreativeInputRequiredResponse', 'BuildCreativeRequest', 'BuildCreativeSubmittedResponse', 'BuildCreativeResponse', 'BuildCreativeWorkingResponse', 'CalibrateContentRequest', 'CalibrateContentResponse', 'CheckGovernanceRequest', 'CheckGovernanceResponse', 'ComplyTestControllerRequest', 'ComplyTestControllerResponse', 'ContextMatchRequest', 'ContextMatchResponse', 'CreateCollectionListRequest', 'CreateCollectionListResponse', 'CreateContentStandardsRequest', 'CreateContentStandardsResponse', 'CreateMediaBuyInputRequiredResponse', 'CreateMediaBuyRequest', 'CreateMediaBuySubmittedResponse', 'CreateMediaBuyResponse', 'CreateMediaBuyWorkingResponse', 'CreatePropertyListRequest', 'CreatePropertyListResponse', 'CreativeApprovalRequest', 'CreativeApprovalResponse', 'DeleteCollectionListRequest', 'DeleteCollectionListResponse', 'DeletePropertyListRequest', 'DeletePropertyListResponse', 'GetAccountFinancialsRequest', 'GetAccountFinancialsResponse', 'GetAdcpCapabilitiesRequest', 'GetAdcpCapabilitiesResponse', 'GetBrandIdentityRequest', 'GetBrandIdentityResponse', 'GetCollectionListRequest', 'GetCollectionListResponse', 'GetContentStandardsRequest', 'GetContentStandardsResponse', 'GetCreativeDeliveryRequest', 'GetCreativeDeliveryResponse', 'GetCreativeFeaturesRequest', 'GetCreativeFeaturesResponse', 'GetMediaBuyArtifactsRequest', 'GetMediaBuyArtifactsResponse', 'GetMediaBuyDeliveryRequest', 'GetMediaBuyDeliveryResponse', 'GetMediaBuysRequest', 'GetMediaBuysResponse', 'GetPlanAuditLogsRequest', 'GetPlanAuditLogsResponse', 'GetProductsInputRequiredResponse', 'GetProductsRequest', 'GetProductsSubmittedResponse', 'GetProductsResponse', 'GetProductsWorkingResponse', 'GetPropertyListRequest', 'GetPropertyListResponse', 'GetRightsRequest', 'GetRightsResponse', 'GetSignalsRequest', 'GetSignalsSubmittedResponse', 'GetSignalsResponse', 'GetSignalsWorkingResponse', 'GetTaskStatusRequest', 'GetTaskStatusResponse', 'IdentityMatchRequest', 'IdentityMatchResponse', 'ListAccountsRequest', 'ListAccountsResponse', 'ListCollectionListsRequest', 'ListCollectionListsResponse', 'ListContentStandardsRequest', 'ListContentStandardsResponse', 'ListCreativeFormatsRequest', 'ListCreativeFormatsResponse', 'ListCreativesRequest', 'ListCreativesResponse', 'ListPropertyListsRequest', 'ListPropertyListsResponse', 'ListTasksRequest', 'ListTasksResponse', 'ListTransformersRequest', 'ListTransformersResponse', 'LogEventRequest', 'LogEventResponse', 'PackageRequest', 'PreviewCreativeRequest', 'PreviewCreativeResponse', 'ProvidePerformanceFeedbackRequest', 'ProvidePerformanceFeedbackResponse', 'ProviderIdentityMatchResponse', 'ReportPlanOutcomeRequest', 'ReportPlanOutcomeResponse', 'ReportUsageRequest', 'ReportUsageResponse', 'SearchBrandsRequest', 'SearchBrandsResponse', 'SiGetOfferingRequest', 'SiGetOfferingResponse', 'SiInitiateSessionRequest', 'SiInitiateSessionResponse', 'SiSendMessageRequest', 'SiSendMessageResponse', 'SiTerminateSessionRequest', 'SiTerminateSessionResponse', 'StaleResponse', 'SyncAccountsRequest', 'SyncAccountsResponse', 'SyncAudiencesRequest', 'SyncAudiencesResponse', 'SyncCatalogsInputRequiredResponse', 'SyncCatalogsRequest', 'SyncCatalogsSubmittedResponse', 'SyncCatalogsResponse', 'SyncCatalogsWorkingResponse', 'SyncCreativesInputRequiredResponse', 'SyncCreativesRequest', 'SyncCreativesSubmittedResponse', 'SyncCreativesResponse', 'SyncCreativesWorkingResponse', 'SyncEventSourcesRequest', 'SyncEventSourcesResponse', 'SyncGovernanceRequest', 'SyncGovernanceResponse', 'SyncPlansRequest', 'SyncPlansResponse', 'TasksGetRequest', 'TasksGetResponse', 'TasksListRequest', 'TasksListResponse', 'UpdateCollectionListRequest', 'UpdateCollectionListResponse', 'UpdateContentStandardsRequest', 'UpdateContentStandardsResponse', 'UpdateMediaBuyInputRequiredResponse', 'UpdateMediaBuyRequest', 'UpdateMediaBuySubmittedResponse', 'UpdateMediaBuyResponse', 'UpdateMediaBuyWorkingResponse', 'UpdatePropertyListRequest', 'UpdatePropertyListResponse', 'UpdateRightsRequest', 'UpdateRightsResponse', 'ValidateContentDeliveryRequest', 'ValidateContentDeliveryResponse', 'ValidateInputRequest', 'ValidateInputResponse', 'ValidatePropertyDeliveryRequest', 'ValidatePropertyDeliveryResponse', 'VerifyBrandClaimRequest', 'VerifyBrandClaimResponse', 'VerifyBrandClaimsRequest', 'VerifyBrandClaimsResponse']
diff --git a/src/adcp/types/v32.py b/src/adcp/types/v32.py
index b8e6ce20c..2d116b809 100644
--- a/src/adcp/types/v32.py
+++ b/src/adcp/types/v32.py
@@ -1,4 +1,4 @@
-"""Public AdCP 3.2 beta request/response models."""
+"""Public AdCP 3.2 beta boundary models with a generated static typing stub."""
 
 from adcp.types.versioned import versioned_surface
 
diff --git a/src/adcp/types/v32.pyi b/src/adcp/types/v32.pyi
new file mode 100644
index 000000000..238467dfd
--- /dev/null
+++ b/src/adcp/types/v32.pyi
@@ -0,0 +1,31964 @@
+"""Generated typing surface for the dynamic version-scoped models."""
+
+from __future__ import annotations
+
+import builtins
+from typing import Any, Literal, overload
+from typing_extensions import Never, NotRequired, Required, TypedDict
+
+from adcp.types.versioned import VersionedSchemaModel
+
+# Underscored TypedDicts are private stub details used to type nested values.
+# Runtime composition remains dict-based through the public boundary models.
+
+class _ExternalCoreError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_ExternalCoreErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _AcceptProposalRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _AcceptProposalRequestIoAcceptance(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    accepted_at: Required[builtins.str]
+    signatory: Required[builtins.str]
+    signature_id: NotRequired[builtins.str]
+
+class _ExternalCorePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_ExternalCorePushNotificationConfigAuthentication]
+
+class _ExternalCoreReportingWebhook(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: Required[_ExternalCoreReportingWebhookAuthentication]
+    reporting_frequency: Required[Literal['hourly', 'daily', 'monthly']]
+    requested_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+
+class _AcceptProposalRequestOpportunity(TypedDict, total=False):
+    opportunity_id: Required[builtins.str]
+    phase: NotRequired[Literal['exploratory', 'planning', 'active_sourcing']]
+    intent: NotRequired[Literal['test', 'speculative', 'planning', 'live_rfp']]
+    planning_horizon: NotRequired[_ExternalCoreDateRange]
+    response_deadline: NotRequired[builtins.str]
+    status: NotRequired[Literal['closed']]
+    close_reason: NotRequired[Literal['accepted_with_seller', 'purchased_elsewhere', 'selected_alternative', 'not_pursued', 'budget_changed', 'timing_changed', 'other']]
+    close_detail: NotRequired[builtins.str]
+
+class _AcceptProposalResponseAcceptedProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: NotRequired[builtins.str]
+    media_buy_id: Required[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['accepted']]
+    accepted_at: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _AcceptProposalResponsePurchaseBindingsItem(TypedDict, total=False):
+    purchase_index: Required[builtins.int]
+    product_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+
+class _AcceptProposalResponseAvailableActionsItemVariant1(TypedDict, total=False):
+    task: Required[Literal['control_media_buy']]
+    action: Required[Literal['pause', 'resume', 'cancel', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'update_catalog_assignments', 'update_keywords', 'update_optimization_goals', 'update_impression_goal', 'update_spend_target', 'update_reporting_webhook', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _AcceptProposalResponseAvailableActionsItemVariant2(TypedDict, total=False):
+    task: Required[Literal['refine_proposals']]
+    action: Required[Literal['cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'add_packages', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _AcceptProposalResponseAvailableActionsItemVariant3(TypedDict, total=False):
+    task: Required[Literal['sync_creatives']]
+    action: Required[Literal['replace_creative', 'update_creative_assignments', 'remove_creative']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _AcceptProposalResponseWarningsItem(TypedDict, total=False):
+    code: Required[Literal['inventory_shortfall_forecast', 'flight_change_creates_pacing_risk']]
+    message: Required[builtins.str]
+    affected_resource: Required[_ExternalCoreWarningResource]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreBrandRef(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_ExternalCoreBrandRefDataSubjectContestation]
+    brand_kit_override: NotRequired[_ExternalCoreBrandRefBrandKitOverride]
+
+class _AcquireRightsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _AcquireRightsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _AcquireRightsRequestCampaign(TypedDict, total=False):
+    description: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_kinds: NotRequired[builtins.list[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]]
+    format_option_refs: NotRequired[builtins.list[_AcquireRightsRequestCampaignFormatOptionRefsItemVariant1 | _AcquireRightsRequestCampaignFormatOptionRefsItemVariant2]]
+    estimated_impressions: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+
+class _ExternalBrandRightsTerms(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+    period: NotRequired[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual', 'one_time']]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    impression_cap: NotRequired[builtins.int]
+    overage_cpm: NotRequired[builtins.float]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    exclusivity: NotRequired[_ExternalBrandRightsTermsExclusivity]
+
+class _ExternalCoreGenerationCredential(TypedDict, total=False):
+    provider: Required[builtins.str]
+    rights_key: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    expires_at: NotRequired[builtins.str]
+    endpoint: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    text: NotRequired[builtins.str]
+
+class _AcquireRightsResponseRightsConstraint(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_AcquireRightsResponseRightsConstraintRightsAgent]
+    rights_holder: Required[_ExternalCoreBrandRef]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    grant_status: Required[Literal['active', 'paused', 'revoked']]
+    restrictions: NotRequired[builtins.list[builtins.str]]
+    disclosure: NotRequired[_AcquireRightsResponseRightsConstraintDisclosure]
+    creative_approval_required: NotRequired[builtins.bool]
+    verification_url: NotRequired[builtins.str]
+    content_digest: Required[builtins.str]
+    attestation_refs: Required[builtins.list[_AcquireRightsResponseRightsConstraintAttestationRefsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ActivateSignalRequestDestinationsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ActivateSignalRequestDestinationsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ActivateSignalRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ActivateSignalRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ActivateSignalResponseDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant1 | _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant1 | _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1 | _BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeRequestCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1 | _BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatId(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_ms: NotRequired[builtins.float]
+    pixel_ratio: NotRequired[builtins.float]
+
+class _BuildCreativeRequestMaxSpend(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant1 | _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant2 | _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant1 | _BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+    signal_agent_segment_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant2 | _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    signal_agent_segment_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant1 | _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant2 | _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant1 | _BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    signal_agent_segment_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestVariantAxis(TypedDict, total=False):
+    dimension: Required[Literal['voice', 'theme', 'best_of_n', 'transformer_config', 'custom']]
+    field: NotRequired[builtins.str]
+    values: NotRequired[builtins.list[Any]]
+    label: NotRequired[builtins.str]
+
+class _BuildCreativeRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _BuildCreativeRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _BuildCreativeRequestEvaluatorVariant1(TypedDict, total=False):
+    feature_requirement: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    rank_by: NotRequired[builtins.list[_BuildCreativeRequestEvaluatorVariant1RankByItem]]
+    feature_agent: NotRequired[_BuildCreativeRequestEvaluatorVariant1FeatureAgent]
+    eval_budget: NotRequired[_BuildCreativeRequestEvaluatorVariant1EvalBudget]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    exemplars: Required[_BuildCreativeRequestEvaluatorVariant1Exemplars]
+
+class _BuildCreativeRequestEvaluatorVariant2(TypedDict, total=False):
+    feature_requirement: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    rank_by: NotRequired[builtins.list[_BuildCreativeRequestEvaluatorVariant2RankByItem]]
+    feature_agent: NotRequired[_BuildCreativeRequestEvaluatorVariant2FeatureAgent]
+    eval_budget: NotRequired[_BuildCreativeRequestEvaluatorVariant2EvalBudget]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    evaluator_id: Required[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant3(TypedDict, total=False):
+    feature_requirement: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    rank_by: NotRequired[builtins.list[_BuildCreativeRequestEvaluatorVariant3RankByItem]]
+    feature_agent: NotRequired[_BuildCreativeRequestEvaluatorVariant3FeatureAgent]
+    eval_budget: NotRequired[_BuildCreativeRequestEvaluatorVariant3EvalBudget]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    agent_url: Required[builtins.str]
+
+class _BuildCreativeRequestPreviewInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponsePreview(TypedDict, total=False):
+    previews: Required[builtins.list[_BuildCreativeResponsePreviewPreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _ExternalCoreCreativeConsumption(TypedDict, total=False):
+    tokens: NotRequired[builtins.int]
+    images_generated: NotRequired[builtins.int]
+    renders: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponsePreview2(TypedDict, total=False):
+    previews: Required[builtins.list[_BuildCreativeResponsePreview2PreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItem(TypedDict, total=False):
+    build_creative_id: NotRequired[builtins.str]
+    catalog_item_ref: NotRequired[_BuildCreativeResponseCreativesItemCatalogItemRef]
+    signal_condition: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant3]
+    variants: NotRequired[builtins.list[_BuildCreativeResponseCreativesItemVariantsItem]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _BuildCreativeResponseEstimate(TypedDict, total=False):
+    items_total: NotRequired[builtins.int]
+    items_to_produce: NotRequired[builtins.int]
+    conditions_total: NotRequired[builtins.int]
+    variants_per_item: NotRequired[builtins.int]
+    leaves_total: NotRequired[builtins.int]
+    currency: Required[builtins.str]
+    cost_low: Required[builtins.float]
+    cost_high: Required[builtins.float]
+    cost_expected: NotRequired[builtins.float]
+    basis: Required[Literal['fixed', 'estimated_units', 'cpm_deferred']]
+    per_leaf: NotRequired[builtins.list[_BuildCreativeResponseEstimatePerLeafItem]]
+
+class _ExternalCoreBrandKey(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalMediaBuyProductPurchase(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    pricing_option_id: Required[builtins.str]
+    pricing: NotRequired[_ExternalCoreCanonicalPricingOption]
+    format_option_refs: NotRequired[builtins.list[_ExternalMediaBuyProductPurchaseFormatOptionRefsItemVariant1 | _ExternalMediaBuyProductPurchaseFormatOptionRefsItemVariant2]]
+    catalog_ids: NotRequired[builtins.list[builtins.str]]
+    budget: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    min_spend_target: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bidding: NotRequired[_ExternalCoreBiddingPolicy]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant1 | _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant2 | _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant3]]
+    audience_evidence_requirements: NotRequired[_ExternalCoreProductAudienceEvidenceRequirements]
+    audience_evidence_pins: NotRequired[builtins.list[_ExternalCoreAudienceEvidencePin]]
+    agency_estimate_number: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    measurement_terms: NotRequired[_ExternalCoreCanonicalMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCoreCanonicalPerformanceStandard]]
+
+class _BuyProductsRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _BuyProductsRequestBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _BuyProductsRequestBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalCoreBiddingPolicy(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_ExternalCoreBiddingPolicyCostPer]
+    roas: NotRequired[_ExternalCoreBiddingPolicyRoas]
+
+class _ExternalCoreBusinessEntity(TypedDict, total=False):
+    legal_name: Required[builtins.str]
+    vat_id: NotRequired[builtins.str]
+    tax_id: NotRequired[builtins.str]
+    registration_number: NotRequired[builtins.str]
+    address: NotRequired[_ExternalCoreBusinessEntityAddress]
+    contacts: NotRequired[builtins.list[_ExternalCoreBusinessEntityContactsItem]]
+    bank: NotRequired[_ExternalCoreBusinessEntityBank]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuyProductsRequestOpportunity(TypedDict, total=False):
+    opportunity_id: Required[builtins.str]
+    phase: NotRequired[Literal['exploratory', 'planning', 'active_sourcing']]
+    intent: NotRequired[Literal['test', 'speculative', 'planning', 'live_rfp']]
+    planning_horizon: NotRequired[_ExternalCoreDateRange]
+    response_deadline: NotRequired[builtins.str]
+    status: NotRequired[Literal['closed']]
+    close_reason: NotRequired[Literal['accepted_with_seller', 'purchased_elsewhere', 'selected_alternative', 'not_pursued', 'budget_changed', 'timing_changed', 'other']]
+    close_detail: NotRequired[builtins.str]
+
+class _BuyProductsResponseAcceptedProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: NotRequired[builtins.str]
+    media_buy_id: Required[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['accepted']]
+    accepted_at: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _BuyProductsResponsePurchaseBindingsItem(TypedDict, total=False):
+    purchase_index: Required[builtins.int]
+    product_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+
+class _BuyProductsResponseAvailableActionsItemVariant1(TypedDict, total=False):
+    task: Required[Literal['control_media_buy']]
+    action: Required[Literal['pause', 'resume', 'cancel', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'update_catalog_assignments', 'update_keywords', 'update_optimization_goals', 'update_impression_goal', 'update_spend_target', 'update_reporting_webhook', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _BuyProductsResponseAvailableActionsItemVariant2(TypedDict, total=False):
+    task: Required[Literal['refine_proposals']]
+    action: Required[Literal['cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'add_packages', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _BuyProductsResponseAvailableActionsItemVariant3(TypedDict, total=False):
+    task: Required[Literal['sync_creatives']]
+    action: Required[Literal['replace_creative', 'update_creative_assignments', 'remove_creative']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _BuyProductsResponseWarningsItem(TypedDict, total=False):
+    code: Required[Literal['inventory_shortfall_forecast', 'flight_change_creates_pacing_risk']]
+    message: Required[builtins.str]
+    affected_resource: Required[_ExternalCoreWarningResource]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifact(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_ExternalContentStandardsArtifactAssetsItemVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant3 | _ExternalContentStandardsArtifactAssetsItemVariant4]]
+    metadata: NotRequired[_ExternalContentStandardsArtifactMetadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_ExternalContentStandardsArtifactIdentifiers]
+
+class _CalibrateContentResponseFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _CheckGovernanceRequestProposedCommitment(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _CheckGovernanceRequestExecutionCommitment(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreCanonicalProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: NotRequired[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['draft', 'committed', 'accepted']]
+    accepted_at: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _ExternalCorePlannedDelivery(TypedDict, total=False):
+    media_buy_id: NotRequired[builtins.str]
+    proposal_id: NotRequired[builtins.str]
+    proposal_terms_digest: NotRequired[builtins.str]
+    geo: NotRequired[_ExternalCorePlannedDeliveryGeo]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    frequency_cap: NotRequired[_ExternalCoreFrequencyCap]
+    audience_summary: NotRequired[builtins.str]
+    audience_targeting: NotRequired[builtins.list[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant4]]
+    total_budget: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    budget_cap_timezone: NotRequired[builtins.str]
+    currency: NotRequired[builtins.str]
+    budget_allocation: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant1 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bidding: NotRequired[_ExternalCorePlannedDeliveryBidding]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestDeliveryMetrics(TypedDict, total=False):
+    statement_id: NotRequired[builtins.str]
+    statement_digest: NotRequired[builtins.str]
+    sequence: NotRequired[builtins.int]
+    issued_at: NotRequired[builtins.str]
+    reporting_period: Required[_CheckGovernanceRequestDeliveryMetricsReportingPeriod]
+    spend: NotRequired[builtins.float]
+    cumulative_spend: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    cumulative_impressions: NotRequired[builtins.int]
+    geo_distribution: NotRequired[builtins.dict[builtins.str, builtins.float]]
+    channel_distribution: NotRequired[builtins.dict[builtins.str, builtins.float]]
+    pacing: NotRequired[Literal['ahead', 'on_track', 'behind']]
+    audience_distribution: NotRequired[_CheckGovernanceRequestDeliveryMetricsAudienceDistribution]
+
+class _CheckGovernanceRequestRuntimeAttestationsItem(TypedDict, total=False):
+    issuer: Required[_CheckGovernanceRequestRuntimeAttestationsItemIssuerVariant1 | _CheckGovernanceRequestRuntimeAttestationsItemIssuerVariant2 | _CheckGovernanceRequestRuntimeAttestationsItemIssuerVariant3]
+    claim_type: Required[builtins.str]
+    subject: Required[_CheckGovernanceRequestRuntimeAttestationsItemSubjectVariant1 | _CheckGovernanceRequestRuntimeAttestationsItemSubjectVariant2 | _CheckGovernanceRequestRuntimeAttestationsItemSubjectVariant3]
+    locator: NotRequired[_CheckGovernanceRequestRuntimeAttestationsItemLocatorVariant1 | _CheckGovernanceRequestRuntimeAttestationsItemLocatorVariant2]
+    embedded_credential: NotRequired[_CheckGovernanceRequestRuntimeAttestationsItemEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_CheckGovernanceRequestRuntimeAttestationsItemValidityHint]
+    verify_agent: NotRequired[_CheckGovernanceRequestRuntimeAttestationsItemVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceResponseFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    policy_id: NotRequired[builtins.str]
+    source_plan_id: NotRequired[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    confidence: NotRequired[builtins.float]
+    uncertainty_reason: NotRequired[builtins.str]
+    attestation_reference_digest: NotRequired[builtins.str]
+
+class _CheckGovernanceResponseConditionsItem(TypedDict, total=False):
+    field: Required[builtins.str]
+    required_value: NotRequired[Any]
+    reason: Required[builtins.str]
+
+class _CheckGovernanceResponseDeliveryStatement(TypedDict, total=False):
+    statement_id: Required[builtins.str]
+    statement_digest: Required[builtins.str]
+    sequence: Required[builtins.int]
+    issued_at: Required[builtins.str]
+    seller_reference: Required[builtins.str]
+    reporting_period: Required[_CheckGovernanceResponseDeliveryStatementReportingPeriod]
+    cumulative_spend: Required[builtins.float]
+    currency: Required[builtins.str]
+    canonical_payload: Required[_CheckGovernanceResponseDeliveryStatementCanonicalPayload]
+
+class _CheckGovernanceResponseRuntimeAttestationEvaluationsItem(TypedDict, total=False):
+    reference_digest: Required[builtins.str]
+    credential_digest: NotRequired[builtins.str]
+    proof_format: NotRequired[builtins.str]
+    outcome: Required[Literal['verified', 'not_found', 'expired', 'revoked', 'invalid', 'unsupported', 'unverifiable', 'untrusted_issuer', 'untrusted_resolver', 'subject_mismatch', 'digest_mismatch', 'resolution_failed']]
+    evaluated_at: Required[builtins.str]
+    evaluated_by: Required[builtins.str]
+    verifier_agent_url: NotRequired[builtins.str]
+    reason_codes: NotRequired[builtins.list[builtins.str]]
+    confidence: NotRequired[builtins.float]
+    revocation_checked_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    action_binding: Required[_CheckGovernanceResponseRuntimeAttestationEvaluationsItemActionBinding]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerRequestParams(TypedDict, total=False):
+    creative_id: NotRequired[builtins.str]
+    account_id: NotRequired[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    session_id: NotRequired[builtins.str]
+    product_id: NotRequired[builtins.str]
+    pricing_option_id: NotRequired[builtins.str]
+    plan_id: NotRequired[builtins.str]
+    rights_id: NotRequired[builtins.str]
+    fixture: NotRequired[builtins.dict[builtins.str, Any]]
+    operation: NotRequired[Literal['seed_inaccessible_item', 'query_eligibility', 'advance_time', 'recreate_catalog']]
+    catalog_id: NotRequired[builtins.str]
+    catalog_generation: NotRequired[builtins.str]
+    item_id: NotRequired[builtins.str]
+    target_time: NotRequired[builtins.str]
+    status: NotRequired[builtins.str]
+    rejection_reason: NotRequired[builtins.str]
+    purge_kind: NotRequired[Literal['soft', 'hard']]
+    reason_code: NotRequired[Literal['review_passed', 'review_failure', 'processing_failure', 'seller_rereview', 'policy_revocation', 'content_drift', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_deleted', 'takedown_request', 'advertiser_request', 'seller_archive', 'account_closed', 'account_suspended', 'retention_expired', 'legal_erasure']]
+    reason_detail: NotRequired[builtins.str]
+    termination_reason: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    clicks: NotRequired[builtins.int]
+    conversions: NotRequired[builtins.int]
+    delivery_date: NotRequired[builtins.str]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    reported_spend: NotRequired[_ComplyTestControllerRequestParamsReportedSpend]
+    reach: NotRequired[builtins.float]
+    frequency: NotRequired[builtins.float]
+    reach_window: NotRequired[_ComplyTestControllerRequestParamsReachWindow]
+    viewability: NotRequired[_ComplyTestControllerRequestParamsViewability]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    vendor_metric_values_by_package: NotRequired[builtins.dict[builtins.str, builtins.list[_ExternalCoreVendorMetricValue]]]
+    not_yet_measurable_vendor_metrics: NotRequired[builtins.list[_ComplyTestControllerRequestParamsNotYetMeasurableVendorMetricsItem]]
+    not_yet_measurable_vendor_metrics_by_package: NotRequired[builtins.dict[builtins.str, builtins.list[_ComplyTestControllerRequestParamsNotYetMeasurableVendorMetricsByPackageValueItem]]]
+    spend_percentage: NotRequired[builtins.float]
+    arm: NotRequired[Literal['submitted', 'input-required', 'rejected']]
+    task_id: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+    reason: NotRequired[builtins.str]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+    format_id: NotRequired[builtins.str]
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    metrics: NotRequired[builtins.list[_ComplyTestControllerRequestParamsMetricsItem]]
+    tool: NotRequired[builtins.str]
+    upstream_name: NotRequired[builtins.str]
+    result: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerRequestAccount(TypedDict, total=False):
+    sandbox: Required[Literal[True]]
+
+class _ComplyTestControllerResponseForced(TypedDict, total=False):
+    arm: Required[Literal['submitted', 'input-required', 'rejected']]
+    task_id: NotRequired[builtins.str]
+    reason: NotRequired[builtins.str]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCreativeAuditObservation(TypedDict, total=False):
+    code: Required[Literal['OVERSIGHT_DISCLOSURE_CARVEOUT_CLAIMED']]
+    severity: Required[Literal['audit-worthy']]
+    recovery: Required[Literal['informational']]
+    field: Required[builtins.str]
+    message: Required[builtins.str]
+    details: Required[_ExternalCreativeAuditObservationDetails]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant1(TypedDict, total=False):
+    method: Required[Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']]
+    endpoint: Required[builtins.str]
+    url: Required[builtins.str]
+    host: NotRequired[builtins.str]
+    path: NotRequired[builtins.str]
+    content_type: Required[builtins.str]
+    attestation_mode: Required[Literal['raw']]
+    purpose: NotRequired[Literal['platform_primary', 'measurement', 'attribution', 'creative_serving', 'identity', 'other']]
+    payload: Required[Any]
+    payload_digest_sha256: NotRequired[builtins.str]
+    payload_length: Required[builtins.int]
+    identifier_match_proofs: NotRequired[builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant1IdentifierMatchProofsItem]]
+    timestamp: Required[builtins.str]
+    status_code: NotRequired[builtins.int]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant2(TypedDict, total=False):
+    method: Required[Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']]
+    endpoint: Required[builtins.str]
+    url: Required[builtins.str]
+    host: NotRequired[builtins.str]
+    path: NotRequired[builtins.str]
+    content_type: Required[builtins.str]
+    attestation_mode: Required[Literal['digest']]
+    purpose: NotRequired[Literal['platform_primary', 'measurement', 'attribution', 'creative_serving', 'identity', 'other']]
+    payload: NotRequired[Any]
+    payload_digest_sha256: Required[builtins.str]
+    payload_length: Required[builtins.int]
+    identifier_match_proofs: NotRequired[builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant2IdentifierMatchProofsItem]]
+    timestamp: Required[builtins.str]
+    status_code: NotRequired[builtins.int]
+
+class _ContextMatchRequestArtifactRefsItem(TypedDict, total=False):
+    type: Required[Literal['url', 'url_hash', 'eidr', 'gracenote', 'isrc', 'gtin', 'rss_guid', 'isbn', 'custom']]
+    value: Required[builtins.str]
+
+class _ContextMatchRequestGeo(TypedDict, total=False):
+    country: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    metro: NotRequired[_ContextMatchRequestGeoMetro]
+
+class _ContextMatchRequestContextSignals(TypedDict, total=False):
+    topics: NotRequired[builtins.list[builtins.str]]
+    taxonomy_source: NotRequired[builtins.str]
+    taxonomy_id: NotRequired[builtins.int]
+    sentiment: NotRequired[Literal['positive', 'negative', 'neutral', 'mixed']]
+    keywords: NotRequired[builtins.list[builtins.str]]
+    language: NotRequired[builtins.str]
+    content_policies: NotRequired[builtins.list[builtins.str]]
+    summary: NotRequired[builtins.str]
+    embedding: NotRequired[builtins.str]
+    embedding_model: NotRequired[builtins.str]
+    embedding_dims: NotRequired[builtins.int]
+
+class _ExternalTrustedMatchOffer(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    seller_agent: NotRequired[_ExternalCoreSellerAgentRef]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    price: NotRequired[_ExternalTrustedMatchOfferPrice]
+    summary: NotRequired[builtins.str]
+    creative_manifest: NotRequired[_ExternalTrustedMatchOfferCreativeManifestVariant1 | _ExternalTrustedMatchOfferCreativeManifestVariant2]
+    creative_data: NotRequired[builtins.dict[builtins.str, builtins.str]]
+
+class _ContextMatchResponseSignals(TypedDict, total=False):
+    segments: NotRequired[builtins.list[builtins.str]]
+
+class _ContextMatchResponseSignalsByProviderValue(TypedDict, total=False):
+    targeting_kvs: Required[builtins.list[_TargetingKvsItem]]
+
+class _ControlMediaBuyRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalMediaBuyPackageControl(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    budget: NotRequired[builtins.float | None]
+    daily_budget_cap: NotRequired[builtins.float | None]
+    min_spend_target: NotRequired[builtins.float | None]
+    impressions: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bidding: NotRequired[_ExternalCoreBiddingPolicy | None]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[Literal[True]]
+    cancellation_reason: NotRequired[builtins.str]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    catalog_ids: NotRequired[builtins.list[builtins.str]]
+    keyword_targets_add: NotRequired[builtins.list[_ExternalCoreKeywordTarget]]
+    keyword_targets_remove: NotRequired[builtins.list[_ExternalCoreKeywordTarget]]
+    negative_keywords_add: NotRequired[builtins.list[_ExternalCoreKeywordTarget]]
+    negative_keywords_remove: NotRequired[builtins.list[_ExternalCoreKeywordTarget]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageControlOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant2 | _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant3]]
+
+class _ControlMediaBuyResponseAvailableActionsItemVariant1(TypedDict, total=False):
+    task: Required[Literal['control_media_buy']]
+    action: Required[Literal['pause', 'resume', 'cancel', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'update_catalog_assignments', 'update_keywords', 'update_optimization_goals', 'update_impression_goal', 'update_spend_target', 'update_reporting_webhook', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ControlMediaBuyResponseAvailableActionsItemVariant2(TypedDict, total=False):
+    task: Required[Literal['refine_proposals']]
+    action: Required[Literal['cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'add_packages', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ControlMediaBuyResponseAvailableActionsItemVariant3(TypedDict, total=False):
+    task: Required[Literal['sync_creatives']]
+    action: Required[Literal['replace_creative', 'update_creative_assignments', 'remove_creative']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ControlMediaBuyResponseWarningsItem(TypedDict, total=False):
+    code: Required[Literal['inventory_shortfall_forecast']]
+    message: Required[builtins.str]
+    affected_resource: Required[_ExternalCoreWarningResource]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreateCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _ExternalCollectionCollectionListFilters(TypedDict, total=False):
+    content_ratings_exclude: NotRequired[builtins.list[_ExternalCoreContentRating]]
+    content_ratings_include: NotRequired[builtins.list[_ExternalCoreContentRating]]
+    genres_exclude: NotRequired[builtins.list[builtins.str]]
+    genres_include: NotRequired[builtins.list[builtins.str]]
+    genre_taxonomy: NotRequired[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+    kinds: NotRequired[builtins.list[Literal['series', 'publication', 'event_series', 'rotation']]]
+    exclude_distribution_ids: NotRequired[builtins.list[_ExternalCollectionCollectionListFiltersExcludeDistributionIdsItem]]
+    production_quality: NotRequired[builtins.list[Literal['professional', 'prosumer', 'ugc']]]
+
+class _ExternalCollectionCollectionList(TypedDict, total=False):
+    list_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    account: NotRequired[_ExternalCollectionCollectionListAccountVariant1 | _ExternalCollectionCollectionListAccountVariant2]
+    base_collections: NotRequired[builtins.list[_ExternalCollectionCollectionListBaseCollectionsItemVariant1 | _ExternalCollectionCollectionListBaseCollectionsItemVariant2 | _ExternalCollectionCollectionListBaseCollectionsItemVariant3]]
+    filters: NotRequired[_ExternalCollectionCollectionListFilters]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    webhook_url: NotRequired[builtins.str]
+    cache_duration_hours: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    collection_count: NotRequired[builtins.int]
+
+class _CreateContentStandardsRequestScope(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: Required[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _ExternalGovernancePolicyEntry(TypedDict, total=False):
+    policy_id: Required[builtins.str]
+    source: NotRequired[Literal['registry', 'inline']]
+    version: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    category: NotRequired[Literal['regulation', 'standard']]
+    enforcement: Required[Literal['must', 'should', 'may']]
+    requires_human_review: NotRequired[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[builtins.str]]
+    region_aliases: NotRequired[builtins.dict[builtins.str, builtins.list[builtins.str]]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    governance_domains: NotRequired[builtins.list[Literal['campaign', 'property', 'creative', 'content_standards']]]
+    effective_date: NotRequired[builtins.str]
+    sunset_date: NotRequired[builtins.str]
+    source_url: NotRequired[builtins.str]
+    source_name: NotRequired[builtins.str]
+    policy: Required[builtins.str]
+    guidance: NotRequired[builtins.str]
+    exemplars: NotRequired[_ExternalGovernancePolicyEntryExemplars]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2]]
+
+class _CreateMediaBuyRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreateMediaBuyRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreateMediaBuyRequestOpportunity(TypedDict, total=False):
+    opportunity_id: Required[builtins.str]
+    phase: NotRequired[Literal['exploratory', 'planning', 'active_sourcing']]
+    intent: NotRequired[Literal['test', 'speculative', 'planning', 'live_rfp']]
+    planning_horizon: NotRequired[_ExternalCoreDateRange]
+    response_deadline: NotRequired[builtins.str]
+    status: NotRequired[Literal['closed']]
+    close_reason: NotRequired[Literal['accepted_with_seller', 'purchased_elsewhere', 'selected_alternative', 'not_pursued', 'budget_changed', 'timing_changed', 'other']]
+    close_detail: NotRequired[builtins.str]
+
+class _CreateMediaBuyRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalMediaBuyPackageRequest(TypedDict, total=False):
+    adcp_version: NotRequired[builtins.str]
+    adcp_major_version: NotRequired[builtins.int]
+    product_id: Required[builtins.str]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_option_refs: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant1 | _ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    budget: NotRequired[builtins.float]
+    min_spend_target: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: Required[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    bidding: NotRequired[_ExternalMediaBuyPackageRequestBidding]
+    impressions: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    audience_evidence_requirements: NotRequired[_ExternalCoreAudienceEvidenceRequirements]
+    audience_evidence_pins: NotRequired[builtins.list[_ExternalCoreAudienceEvidencePin]]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    committed_metrics: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1 | _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant2]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    creatives: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCreativesItemVariant1 | _ExternalMediaBuyPackageRequestCreativesItemVariant2]]
+    agency_estimate_number: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateMediaBuyRequestIoAcceptance(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    accepted_at: Required[builtins.str]
+    signatory: Required[builtins.str]
+    signature_id: NotRequired[builtins.str]
+
+class _CreateMediaBuyRequestBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_CreateMediaBuyRequestBiddingCostPer]
+    roas: NotRequired[_CreateMediaBuyRequestBiddingRoas]
+
+class _CreateMediaBuyRequestArtifactWebhook(TypedDict, total=False):
+    url: Required[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: Required[_CreateMediaBuyRequestArtifactWebhookAuthentication]
+    delivery_mode: Required[Literal['realtime', 'batched']]
+    batch_frequency: NotRequired[Literal['hourly', 'daily']]
+    sampling_rate: NotRequired[builtins.float]
+
+class _ExternalCoreAccount(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    revision: NotRequired[builtins.int]
+    identity_change: NotRequired[_ExternalCoreAccountIdentityChangeVariant1 | _ExternalCoreAccountIdentityChangeVariant2]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    destination_billing_entity: NotRequired[Any]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_ExternalCoreAccountCreditLimit]
+    setup: NotRequired[_ExternalCoreAccountSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_ExternalCoreAccountGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_ExternalCoreAccountReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_ExternalCoreNotificationConfig]]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _CreateMediaBuyResponseBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_CreateMediaBuyResponseBiddingCostPer]
+    roas: NotRequired[_CreateMediaBuyResponseBiddingRoas]
+
+class _ExternalCoreMediaBuyAvailableAction(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    task: NotRequired[Literal['control_media_buy', 'refine_proposals', 'sync_creatives']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ExternalCorePackage(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    audience_evidence_selections: NotRequired[builtins.list[_ExternalCoreAudienceEvidenceSelection]]
+    budget: NotRequired[builtins.float]
+    min_spend_target: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    bidding: NotRequired[_ExternalCorePackageBidding]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    impressions: NotRequired[builtins.float]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_option_refs: NotRequired[builtins.list[_ExternalCorePackageFormatOptionRefsItemVariant1 | _ExternalCorePackageFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    targeting_resolution: NotRequired[_ExternalCorePackageTargetingResolution]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    committed_metrics: NotRequired[builtins.list[_ExternalCorePackageCommittedMetricsItemVariant1 | _ExternalCorePackageCommittedMetricsItemVariant2]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    formats_to_provide: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1 | _ExternalCorePackageFormatsToProvideItemVariant2 | _ExternalCorePackageFormatsToProvideItemVariant3 | _ExternalCorePackageFormatsToProvideItemVariant4 | _ExternalCorePackageFormatsToProvideItemVariant5 | _ExternalCorePackageFormatsToProvideItemVariant6 | _ExternalCorePackageFormatsToProvideItemVariant7 | _ExternalCorePackageFormatsToProvideItemVariant8 | _ExternalCorePackageFormatsToProvideItemVariant9 | _ExternalCorePackageFormatsToProvideItemVariant10 | _ExternalCorePackageFormatsToProvideItemVariant11 | _ExternalCorePackageFormatsToProvideItemVariant12 | _ExternalCorePackageFormatsToProvideItemVariant13]]
+    formats_pending: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1 | _ExternalCorePackageFormatsPendingItemVariant2 | _ExternalCorePackageFormatsPendingItemVariant3 | _ExternalCorePackageFormatsPendingItemVariant4 | _ExternalCorePackageFormatsPendingItemVariant5 | _ExternalCorePackageFormatsPendingItemVariant6 | _ExternalCorePackageFormatsPendingItemVariant7 | _ExternalCorePackageFormatsPendingItemVariant8 | _ExternalCorePackageFormatsPendingItemVariant9 | _ExternalCorePackageFormatsPendingItemVariant10 | _ExternalCorePackageFormatsPendingItemVariant11 | _ExternalCorePackageFormatsPendingItemVariant12 | _ExternalCorePackageFormatsPendingItemVariant13]]
+    format_ids_to_provide: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_ids_pending: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    optimization_goals: NotRequired[builtins.list[_ExternalCorePackageOptimizationGoalsItemVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant2 | _ExternalCorePackageOptimizationGoalsItemVariant3]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_ExternalCorePackageCancellation]
+    agency_estimate_number: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreWarning(TypedDict, total=False):
+    code: Required[Literal['inventory_shortfall_forecast', 'flight_change_creates_pacing_risk', 'fields_ignored_due_to_precedence']]
+    message: Required[builtins.str]
+    affected_resource: Required[_ExternalCoreWarningResource]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreatePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _CreatePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _CreatePropertyListRequestBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyListFilters(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    property_types: NotRequired[builtins.list[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]]
+    feature_requirements: NotRequired[builtins.list[_ExternalCoreFeatureRequirement]]
+    exclude_identifiers: NotRequired[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyList(TypedDict, total=False):
+    list_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    account: NotRequired[_ExternalPropertyPropertyListAccountVariant1 | _ExternalPropertyPropertyListAccountVariant2]
+    base_properties: NotRequired[builtins.list[_ExternalPropertyPropertyListBasePropertiesItemVariant1 | _ExternalPropertyPropertyListBasePropertiesItemVariant2 | _ExternalPropertyPropertyListBasePropertiesItemVariant3]]
+    filters: NotRequired[_ExternalPropertyPropertyListFilters]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    webhook_url: NotRequired[builtins.str]
+    cache_duration_hours: NotRequired[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    property_count: NotRequired[builtins.int]
+    pricing_options: NotRequired[builtins.list[_ExternalPropertyPropertyListPricingOptionsItemVariant1 | _ExternalPropertyPropertyListPricingOptionsItemVariant2 | _ExternalPropertyPropertyListPricingOptionsItemVariant3 | _ExternalPropertyPropertyListPricingOptionsItemVariant4 | _ExternalPropertyPropertyListPricingOptionsItemVariant5]]
+
+class _DeclineProposalsRequestPushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_DeclineProposalsRequestPushNotificationConfigAuthentication]
+
+class _ExternalMediaBuyProposalDecline(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    reason: Required[Literal['price', 'inventory_fit', 'audience_fit', 'creative_unsupported', 'measurement_unsupported', 'policy', 'timing', 'budget_changed', 'selected_alternative', 'other']]
+    detail: NotRequired[builtins.str]
+
+class _ExternalCoreOpportunityContext(TypedDict, total=False):
+    opportunity_id: Required[builtins.str]
+    phase: NotRequired[Literal['exploratory', 'planning', 'active_sourcing']]
+    intent: NotRequired[Literal['test', 'speculative', 'planning', 'live_rfp']]
+    planning_horizon: NotRequired[_ExternalCoreDateRange]
+    response_deadline: NotRequired[builtins.str]
+    status: NotRequired[Literal['open', 'closed']]
+    close_reason: NotRequired[Literal['accepted_with_seller', 'purchased_elsewhere', 'selected_alternative', 'not_pursued', 'budget_changed', 'timing_changed', 'other']]
+    close_detail: NotRequired[builtins.str]
+
+class _DeclineProposalsResponseResultsItemVariant1(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    outcome: Required[Literal['declined']]
+    reason: NotRequired[builtins.str]
+
+class _DeclineProposalsResponseResultsItemVariant2(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    outcome: Required[Literal['unable']]
+    reason: Required[builtins.str]
+
+class _DeleteCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _DeleteCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _DeletePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _DeletePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAccountFinancialsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetAccountFinancialsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreDateRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _GetAccountFinancialsResponseAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetAccountFinancialsResponseAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAccountFinancialsResponseSpend(TypedDict, total=False):
+    total_spend: Required[builtins.float]
+    media_buy_count: NotRequired[builtins.int]
+
+class _GetAccountFinancialsResponseCredit(TypedDict, total=False):
+    credit_limit: Required[builtins.float]
+    available_credit: Required[builtins.float]
+    utilization_percent: NotRequired[builtins.float]
+
+class _GetAccountFinancialsResponseBalance(TypedDict, total=False):
+    available: Required[builtins.float]
+    last_top_up: NotRequired[_GetAccountFinancialsResponseBalanceLastTopUp]
+
+class _GetAccountFinancialsResponseInvoicesItem(TypedDict, total=False):
+    invoice_id: Required[builtins.str]
+    period: NotRequired[_ExternalCoreDateRange]
+    amount: Required[builtins.float]
+    status: Required[Literal['draft', 'issued', 'paid', 'past_due', 'void']]
+    due_date: NotRequired[builtins.str]
+    paid_date: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcp(TypedDict, total=False):
+    major_versions: Required[builtins.list[builtins.int]]
+    supported_versions: NotRequired[builtins.list[builtins.str]]
+    build_version: NotRequired[builtins.str]
+    idempotency: Required[_GetAdcpCapabilitiesResponseAdcpIdempotencyVariant1 | _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant2]
+    capability_changes: NotRequired[_GetAdcpCapabilitiesResponseAdcpCapabilityChanges]
+    governance_enforcement: NotRequired[_GetAdcpCapabilitiesResponseAdcpGovernanceEnforcement]
+    attestations: NotRequired[_ExternalCoreAttestationCapabilities]
+
+class _GetAdcpCapabilitiesResponseAccount(TypedDict, total=False):
+    require_operator_auth: NotRequired[builtins.bool]
+    authorization_endpoint: NotRequired[builtins.str]
+    supported_billing: Required[builtins.list[Literal['operator', 'agent', 'advertiser']]]
+    supported_account_currency_modes: NotRequired[builtins.list[Literal['fixed', 'per_media_buy']]]
+    timezone: NotRequired[_ExternalCoreAccountTimezoneCapability]
+    required_for_products: NotRequired[builtins.bool]
+    account_financials: NotRequired[builtins.bool]
+    notifications: NotRequired[_GetAdcpCapabilitiesResponseAccountNotificationsVariant1 | _GetAdcpCapabilitiesResponseAccountNotificationsVariant2]
+    identity_updates: NotRequired[_GetAdcpCapabilitiesResponseAccountIdentityUpdatesVariant1 | _GetAdcpCapabilitiesResponseAccountIdentityUpdatesVariant2]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuy(TypedDict, total=False):
+    supported_pricing_models: NotRequired[builtins.list[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'revenue_share', 'flat_rate', 'time']]]
+    buying_modes: NotRequired[builtins.list[Literal['brief', 'wholesale', 'refine']]]
+    lifecycle_tools: NotRequired[builtins.list[Literal['list_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'buy_products', 'accept_proposal', 'control_media_buy']]]
+    proposal_refinement: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyProposalRefinement]
+    reporting_delivery_methods: NotRequired[builtins.list[Literal['webhook', 'offline']]]
+    performance_feedback: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyPerformanceFeedback]
+    offline_delivery_protocols: NotRequired[builtins.list[Literal['s3', 'gcs', 'azure_blob']]]
+    supports_proposals: NotRequired[builtins.bool]
+    governance_aware: NotRequired[builtins.bool]
+    propagation_surfaces: NotRequired[builtins.list[Literal['snapshot', 'webhook', 'out_of_band']]]
+    creative_approval_mode: NotRequired[Literal['auto_approve', 'require_human']]
+    supported_indicator_types: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    relationship_notifications: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyRelationshipNotifications]
+    features: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyFeatures]
+    execution: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecution]
+    audience_evidence: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceEvidence]
+    rights_attestations: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyRightsAttestations]
+    audience_targeting: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceTargeting]
+    supported_optimization_metrics: NotRequired[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    vendor_metric_optimization: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyVendorMetricOptimization]
+    conversion_tracking: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyConversionTracking]
+    frequency_capping: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyFrequencyCapping]
+    budget_capping: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyBudgetCapping]
+    content_standards: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyContentStandards]
+    portfolio: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyPortfolio]
+
+class _GetAdcpCapabilitiesResponseSignals(TypedDict, total=False):
+    data_provider_domains: NotRequired[builtins.list[builtins.str]]
+    discovery_modes: NotRequired[builtins.list[Literal['brief', 'wholesale']]]
+    features: NotRequired[_GetAdcpCapabilitiesResponseSignalsFeatures]
+
+class _GetAdcpCapabilitiesResponseGovernance(TypedDict, total=False):
+    runtime_attestations: NotRequired[_GetAdcpCapabilitiesResponseGovernanceRuntimeAttestations]
+    aggregation_window_days: NotRequired[builtins.int]
+    property_features: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItem]]
+    creative_features: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItem]]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligence(TypedDict, total=False):
+    endpoint: Required[_GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpoint]
+    capabilities: Required[_ExternalSponsoredIntelligenceSiCapabilities]
+    brand_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseBrand(TypedDict, total=False):
+    rights: NotRequired[builtins.bool]
+    right_types: NotRequired[builtins.list[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]]
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    generation_providers: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseCreative(TypedDict, total=False):
+    supports_compliance: NotRequired[builtins.bool]
+    has_creative_library: NotRequired[builtins.bool]
+    supports_generation: NotRequired[builtins.bool]
+    supports_transformation: NotRequired[builtins.bool]
+    supports_transformers: NotRequired[builtins.bool]
+    supports_refinement: NotRequired[builtins.bool]
+    supports_spend_controls: NotRequired[builtins.bool]
+    supports_evaluator: NotRequired[builtins.bool]
+    refinable_retention_seconds: NotRequired[builtins.int]
+    multiplicity: NotRequired[_GetAdcpCapabilitiesResponseCreativeMultiplicity]
+    supported_formats: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItem]]
+    localization: NotRequired[_GetAdcpCapabilitiesResponseCreativeLocalization]
+    bills_through_adcp: NotRequired[builtins.bool]
+    canonical_catalog_version: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseOauth(TypedDict, total=False):
+    supported: Required[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseRequestSigning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    covers_content_digest: NotRequired[Literal['required', 'forbidden', 'either']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    warn_for: NotRequired[builtins.list[builtins.str]]
+    supported_for: NotRequired[builtins.list[builtins.str]]
+    protocol_methods_supported_for: NotRequired[builtins.list[builtins.str]]
+    protocol_methods_warn_for: NotRequired[builtins.list[builtins.str]]
+    protocol_methods_required_for: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseWebhookSigning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    profile: NotRequired[Literal['adcp/webhook-signing/v1']]
+    algorithms: NotRequired[builtins.list[Literal['ed25519', 'ecdsa-p256-sha256']]]
+    legacy_hmac_fallback: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseIdentity(TypedDict, total=False):
+    brand_json_url: NotRequired[builtins.str]
+    per_principal_key_isolation: NotRequired[builtins.bool]
+    key_origins: NotRequired[_GetAdcpCapabilitiesResponseIdentityKeyOrigins]
+    compromise_notification: NotRequired[_GetAdcpCapabilitiesResponseIdentityCompromiseNotification]
+
+class _GetAdcpCapabilitiesResponseMeasurementGateway(TypedDict, total=False):
+    delivery_task: Required[Literal['get_media_buy_delivery']]
+    feedback_task: Required[Literal['provide_performance_feedback']]
+
+class _GetAdcpCapabilitiesResponseMeasurement(TypedDict, total=False):
+    produces_performance_feedback: NotRequired[builtins.bool]
+    metrics: Required[builtins.list[_GetAdcpCapabilitiesResponseMeasurementMetricsItem]]
+
+class _GetAdcpCapabilitiesResponseComplianceTesting(TypedDict, total=False):
+    scenarios: Required[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseWholesaleFeedVersioning(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    pricing_version_separate: NotRequired[builtins.bool]
+    cache_scope_account: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseWholesaleFeedWebhooks(TypedDict, total=False):
+    supported: Required[builtins.bool]
+    event_types: NotRequired[builtins.list[Literal['product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+
+class _GetBrandIdentityResponseHouse(TypedDict, total=False):
+    domain: Required[builtins.str]
+    name: Required[builtins.str]
+
+class _GetBrandIdentityResponseLogosItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    orientation: NotRequired[Literal['square', 'horizontal', 'vertical', 'stacked']]
+    background: NotRequired[Literal['dark-bg', 'light-bg', 'transparent-bg']]
+    variant: NotRequired[Literal['primary', 'secondary', 'icon', 'wordmark', 'full-lockup']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    usage: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+
+class _GetBrandIdentityResponseColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str | builtins.list[builtins.str]]
+    secondary: NotRequired[builtins.str | builtins.list[builtins.str]]
+    accent: NotRequired[builtins.str | builtins.list[builtins.str]]
+    background: NotRequired[builtins.str | builtins.list[builtins.str]]
+    text: NotRequired[builtins.str | builtins.list[builtins.str]]
+
+class _GetBrandIdentityResponseFonts(TypedDict, total=False):
+    primary: NotRequired[builtins.str | _FontRoleVariant2]
+    secondary: NotRequired[builtins.str | _FontRoleVariant2]
+
+class _GetBrandIdentityResponseTone(TypedDict, total=False):
+    voice: NotRequired[builtins.str]
+    attributes: NotRequired[builtins.list[builtins.str]]
+    dos: NotRequired[builtins.list[builtins.str]]
+    donts: NotRequired[builtins.list[builtins.str]]
+
+class _GetBrandIdentityResponseVoiceSynthesis(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    voice_id: NotRequired[builtins.str]
+    rights_offering_id: NotRequired[builtins.str]
+    settings: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetBrandIdentityResponseAssetsItem(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'zip', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']]
+    url: Required[builtins.str]
+    tags: NotRequired[builtins.list[builtins.str]]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    duration_seconds: NotRequired[builtins.float]
+    file_size_bytes: NotRequired[builtins.int]
+    format: NotRequired[builtins.str]
+
+class _GetBrandIdentityResponseRights(TypedDict, total=False):
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    exclusivity_model: NotRequired[builtins.str]
+    content_restrictions: NotRequired[builtins.list[builtins.str]]
+
+class _GetCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetCollectionListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetCollectionListResponseCollectionsItem(TypedDict, total=False):
+    collection_rid: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    distribution_ids: NotRequired[builtins.list[_GetCollectionListResponseCollectionsItemDistributionIdsItem]]
+    content_rating: NotRequired[_ExternalCoreContentRating]
+    genre: NotRequired[builtins.list[builtins.str]]
+    genre_taxonomy: NotRequired[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+    kind: NotRequired[Literal['series', 'publication', 'event_series', 'rotation']]
+
+class _ExternalCorePaginationResponse(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _GetCollectionListResponseCoverageGapsValueItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _GetContentStandardsResponseCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_GetContentStandardsResponsePricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCreativeDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCorePaginationRequest(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+    timezone: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_GetCreativeDeliveryResponseCreativesItemFormatOptionRefVariant1 | _GetCreativeDeliveryResponseCreativesItemFormatOptionRefVariant2]
+    totals: NotRequired[_ExternalCoreDeliveryMetrics]
+    variant_count: NotRequired[builtins.int]
+    variants: Required[builtins.list[_ExternalCoreCreativeVariant]]
+
+class _GetCreativeDeliveryResponsePagination(TypedDict, total=False):
+    limit: Required[builtins.int]
+    offset: Required[builtins.int]
+    has_more: Required[builtins.bool]
+    total_count: NotRequired[builtins.int]
+    total: NotRequired[builtins.int]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetCreativeFeaturesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCreativeCreativeFeatureResult(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    value: Required[builtins.bool | builtins.float | builtins.str]
+    unit: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+    measured_at: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    methodology_version: NotRequired[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    policy_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuyArtifactsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuyArtifactsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuyArtifactsRequestTimeRange(TypedDict, total=False):
+    start: NotRequired[builtins.str]
+    end: NotRequired[builtins.str]
+
+class _GetMediaBuyArtifactsRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _GetMediaBuyArtifactsResponseArtifactsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    artifact: Required[_ExternalContentStandardsArtifact]
+    country: NotRequired[builtins.str]
+    channel: NotRequired[builtins.str]
+    brand_context: NotRequired[_GetMediaBuyArtifactsResponseArtifactsItemBrandContext]
+    local_verdict: NotRequired[Literal['pass', 'fail', 'unevaluated']]
+
+class _GetMediaBuyArtifactsResponseCollectionInfo(TypedDict, total=False):
+    total_deliveries: NotRequired[builtins.int]
+    total_collected: NotRequired[builtins.int]
+    returned_count: NotRequired[builtins.int]
+    effective_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuyDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuyDeliveryRequestAttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_GetMediaBuyDeliveryRequestAttributionWindowPostClick]
+    post_view: NotRequired[_GetMediaBuyDeliveryRequestAttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensions(TypedDict, total=False):
+    geo: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsGeo]
+    device_type: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDeviceType]
+    device_platform: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDevicePlatform]
+    audience: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsAudience]
+    demographic: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsDemographic]
+    spot: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsSpot]
+    placement: NotRequired[_GetMediaBuyDeliveryRequestReportingDimensionsPlacement]
+
+class _GetMediaBuyDeliveryResponseReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalCoreAttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCoreAttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCoreAttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotals(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    frequency: NotRequired[builtins.float]
+    media_buy_count: Required[builtins.int]
+    metric_aggregates: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1 | _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant2]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem(TypedDict, total=False):
+    media_buy_id: Required[builtins.str]
+    status: Required[Literal['pending_creatives', 'pending_start', 'pending', 'active', 'paused', 'completed', 'rejected', 'canceled', 'failed', 'reporting_delayed']]
+    expected_availability: NotRequired[builtins.str]
+    is_adjusted: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    pricing_model: NotRequired[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'revenue_share', 'flat_rate', 'time']]
+    pacing_index: NotRequired[builtins.float]
+    totals: Required[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotals]
+    by_package: Required[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItem]]
+    windows: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItem]]
+    daily_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemDailyBreakdownItem]]
+
+class _GetMediaBuysRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetMediaBuysRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItem(TypedDict, total=False):
+    indicators: NotRequired[builtins.list[_ExternalCoreIndicator]]
+    indicator_types_evaluated: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    indicators_as_of: NotRequired[builtins.str]
+    indicators_evaluated_scope: NotRequired[builtins.list[_ExternalCoreIndicatorScope]]
+    media_buy_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    accepted_proposal_id: NotRequired[builtins.str]
+    accepted_proposal_terms_digest: NotRequired[builtins.str]
+    accepted_proposal: NotRequired[_GetMediaBuysResponseMediaBuysItemAcceptedProposal]
+    account: NotRequired[_ExternalCoreAccount]
+    invoice_recipient: NotRequired[_ExternalCoreBusinessEntity]
+    status: Required[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]
+    status_as_of: NotRequired[builtins.str | None]
+    health: NotRequired[Literal['ok', 'impaired']]
+    impairments: NotRequired[builtins.list[_ExternalCoreImpairment]]
+    rejection_reason: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    total_budget: Required[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    budget_cap_timezone: NotRequired[builtins.str]
+    budget_allocation: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant1 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bidding: NotRequired[_GetMediaBuysResponseMediaBuysItemBidding]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    creative_deadline: NotRequired[builtins.str]
+    confirmed_at: Required[builtins.str | None]
+    cancellation: NotRequired[_GetMediaBuysResponseMediaBuysItemCancellation]
+    revision: Required[builtins.int]
+    created_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    valid_actions: NotRequired[builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]]
+    available_actions: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemAvailableActionsItemVariant1Variant1 | _GetMediaBuysResponseMediaBuysItemAvailableActionsItemVariant1Variant2 | _GetMediaBuysResponseMediaBuysItemAvailableActionsItemVariant1Variant3 | _ExternalCoreMediaBuyAvailableAction]]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+    history: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemHistoryItem]]
+    packages: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    plan_version: Required[builtins.int]
+    status: Required[Literal['active', 'suspended', 'completed']]
+    budget: Required[_GetPlanAuditLogsResponsePlansItemBudget]
+    channel_allocation: NotRequired[builtins.dict[builtins.str, _GetPlanAuditLogsResponsePlansItemChannelAllocationValue]]
+    summary: Required[_GetPlanAuditLogsResponsePlansItemSummary]
+    entries: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItem]]
+    governed_actions: Required[builtins.list[_GetPlanAuditLogsResponsePlansItemGovernedActionsItem]]
+
+class _ExternalCoreProduct(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    publisher_properties: Required[builtins.list[_ExternalCoreProductPublisherPropertiesItemVariant1 | _ExternalCoreProductPublisherPropertiesItemVariant2 | _ExternalCoreProductPublisherPropertiesItemVariant3]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_options: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1 | _ExternalCoreProductFormatOptionsItemVariant2 | _ExternalCoreProductFormatOptionsItemVariant3 | _ExternalCoreProductFormatOptionsItemVariant4 | _ExternalCoreProductFormatOptionsItemVariant5 | _ExternalCoreProductFormatOptionsItemVariant6 | _ExternalCoreProductFormatOptionsItemVariant7 | _ExternalCoreProductFormatOptionsItemVariant8 | _ExternalCoreProductFormatOptionsItemVariant9 | _ExternalCoreProductFormatOptionsItemVariant10 | _ExternalCoreProductFormatOptionsItemVariant11 | _ExternalCoreProductFormatOptionsItemVariant12 | _ExternalCoreProductFormatOptionsItemVariant13]]
+    placements: NotRequired[builtins.list[_ExternalCorePlacement]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    delivery_type: Required[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    pricing_options: Required[builtins.list[_ExternalCoreProductPricingOptionsItemVariant1 | _ExternalCoreProductPricingOptionsItemVariant2 | _ExternalCoreProductPricingOptionsItemVariant3 | _ExternalCoreProductPricingOptionsItemVariant4 | _ExternalCoreProductPricingOptionsItemVariant5 | _ExternalCoreProductPricingOptionsItemVariant6 | _ExternalCoreProductPricingOptionsItemVariant7 | _ExternalCoreProductPricingOptionsItemVariant8 | _ExternalCoreProductPricingOptionsItemVariant9 | _ExternalCoreProductPricingOptionsItemVariant10]]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    outcome_measurement: NotRequired[_ExternalCoreOutcomeMeasurement]
+    delivery_measurement: NotRequired[_ExternalCoreProductDeliveryMeasurement]
+    measurement_terms: NotRequired[_ExternalCoreMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    cancellation_policy: NotRequired[_ExternalCoreCancellationPolicy]
+    allowed_actions: NotRequired[builtins.list[_ExternalCoreProductAllowedAction]]
+    reporting_capabilities: Required[_ExternalCoreReportingCapabilities]
+    creative_policy: NotRequired[_ExternalCoreCreativePolicy]
+    is_custom: NotRequired[builtins.bool]
+    property_targeting_allowed: NotRequired[builtins.bool]
+    data_provider_signals: NotRequired[builtins.list[_ExternalCoreProductDataProviderSignalsItemVariant1 | _ExternalCoreProductDataProviderSignalsItemVariant2 | _ExternalCoreProductDataProviderSignalsItemVariant3]]
+    included_signals: NotRequired[builtins.list[_ExternalCoreSignalListing]]
+    signal_targeting_options: NotRequired[builtins.list[_ExternalCoreProductSignalTargetingOption]]
+    signal_targeting_rules: NotRequired[_ExternalCoreSignalTargetingRules]
+    signal_targeting_allowed: NotRequired[builtins.bool]
+    demographic_targeting: NotRequired[_ExternalCoreDemographicTargetingCapability]
+    overlay_support: NotRequired[_ExternalCoreTargetingOverlaySupport]
+    targeting_resolution: NotRequired[_ExternalCoreProductTargetingResolution]
+    audience_evidence: NotRequired[builtins.list[_ExternalCoreAudienceEvidence]]
+    audience_evidence_selections: NotRequired[builtins.list[_ExternalCoreAudienceEvidenceSelection]]
+    catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    metric_optimization: NotRequired[_ExternalCoreProductMetricOptimization]
+    vendor_metric_optimization: NotRequired[_ExternalCoreVendorMetricOptimization]
+    max_optimization_goals: NotRequired[builtins.int]
+    measurement_readiness: NotRequired[_ExternalCoreMeasurementReadiness]
+    conversion_tracking: NotRequired[_ExternalCoreProductConversionTracking]
+    catalog_match: NotRequired[_ExternalCoreProductCatalogMatch]
+    brief_relevance: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    product_card: NotRequired[_ExternalCoreProductProductCard]
+    product_card_detailed: NotRequired[_ExternalCoreProductProductCardDetailed]
+    collections: NotRequired[builtins.list[_ExternalCoreCollectionSelector]]
+    collection_targeting_allowed: NotRequired[builtins.bool]
+    installments: NotRequired[builtins.list[_ExternalCoreInstallment]]
+    enforced_policies: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_ExternalCoreProductTrustedMatch]
+    material_submission: NotRequired[_ExternalCoreProductMaterialSubmission]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetProductsRequestRefineItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    ask: Required[builtins.str]
+
+class _GetProductsRequestRefineItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    action: NotRequired[Literal['include', 'omit', 'more_like_this']]
+    ask: NotRequired[builtins.str]
+
+class _GetProductsRequestRefineItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    action: NotRequired[Literal['include', 'omit', 'finalize']]
+    ask: NotRequired[builtins.str]
+
+class _ExternalCoreCatalog(TypedDict, total=False):
+    catalog_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    url: NotRequired[builtins.str]
+    feed_format: NotRequired[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'tiktok_shop', 'pinterest_catalog', 'openai_product_feed', 'custom']]
+    update_frequency: NotRequired[Literal['realtime', 'hourly', 'daily', 'weekly']]
+    items: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    ids: NotRequired[builtins.list[builtins.str]]
+    gtins: NotRequired[builtins.list[builtins.str]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    category: NotRequired[builtins.str]
+    query: NotRequired[builtins.str]
+    conversion_events: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+    feed_field_mappings: NotRequired[builtins.list[_ExternalCoreCatalogFieldMapping]]
+
+class _GetProductsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetProductsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFilters(TypedDict, total=False):
+    delivery_type: NotRequired[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    is_fixed_price: NotRequired[builtins.bool]
+    pricing_structures: NotRequired[builtins.list[Literal['fixed', 'auction', 'contingent']]]
+    pricing_currencies: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_kinds: NotRequired[builtins.list[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]]
+    format_option_refs: NotRequired[builtins.list[_ExternalCoreProductFiltersFormatOptionRefsItemVariant1 | _ExternalCoreProductFiltersFormatOptionRefsItemVariant2]]
+    standard_formats_only: NotRequired[builtins.bool]
+    min_exposures: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    budget_range: NotRequired[_ExternalCoreProductFiltersBudgetRange]
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+    metros: NotRequired[builtins.list[_ExternalCoreProductFiltersMetrosItem]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    required_axe_integrations: NotRequired[builtins.list[builtins.str]]
+    trusted_match: NotRequired[_ExternalCoreProductFiltersTrustedMatch]
+    required_features: NotRequired[_ExternalCoreMediaBuyFeatures]
+    required_geo_targeting: NotRequired[builtins.list[_ExternalCoreProductFiltersRequiredGeoTargetingItem]]
+    signal_targeting: NotRequired[builtins.list[_ExternalCoreProductFiltersSignalTargetingItemVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant3]]
+    postal_areas: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    geo_proximity: NotRequired[builtins.list[_ExternalCoreProductFiltersGeoProximityItemVariant1 | _ExternalCoreProductFiltersGeoProximityItemVariant2 | _ExternalCoreProductFiltersGeoProximityItemVariant3]]
+    required_performance_standards: NotRequired[builtins.list[_ExternalCorePerformanceStandard]]
+    required_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    required_vendor_metrics: NotRequired[builtins.list[_ExternalCoreProductFiltersRequiredVendorMetricsItem]]
+    keywords: NotRequired[builtins.list[_ExternalCoreProductFiltersKeywordsItem]]
+    audience_evidence_requirements: NotRequired[_ExternalCoreAudienceEvidenceRequirements]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargeting(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.list[builtins.str]]
+    geo_countries_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_regions: NotRequired[builtins.list[builtins.str]]
+    geo_regions_exclude: NotRequired[builtins.list[builtins.str]]
+    geo_metros: NotRequired[builtins.list[_ExternalCoreTargetingGeoMetrosItem]]
+    geo_metros_exclude: NotRequired[builtins.list[_ExternalCoreTargetingGeoMetrosExcludeItem]]
+    geo_postal_areas: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    geo_postal_areas_exclude: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+    geo_places: NotRequired[builtins.list[_ExternalCoreGeoPlaceArea]]
+    geo_places_exclude: NotRequired[builtins.list[_ExternalCoreGeoPlaceArea]]
+    daypart_targets: NotRequired[builtins.list[_ExternalCoreDaypartTarget]]
+    axe_include_segment: NotRequired[builtins.str]
+    axe_exclude_segment: NotRequired[builtins.str]
+    audience_include: NotRequired[builtins.list[builtins.str]]
+    audience_exclude: NotRequired[builtins.list[builtins.str]]
+    signal_targeting_groups: NotRequired[_ExternalCorePackageSignalTargetingGroups]
+    signal_targeting: NotRequired[builtins.list[_ExternalCoreTargetingSignalTargetingItemVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant3]]
+    demographics: NotRequired[_ExternalCoreDemographicTargetingIntent]
+    frequency_cap: NotRequired[_ExternalCoreFrequencyCap]
+    property_list: NotRequired[_ExternalCorePropertyListRef]
+    property_list_exclude: NotRequired[_ExternalCorePropertyListRef]
+    collection_list: NotRequired[_ExternalCoreCollectionListRef]
+    collection_list_exclude: NotRequired[_ExternalCoreCollectionListRef]
+    placement_selection: NotRequired[_ExternalCoreTargetingPlacementSelectionVariant1 | _ExternalCoreTargetingPlacementSelectionVariant2]
+    age_restriction: NotRequired[_ExternalCoreTargetingAgeRestriction]
+    device_platform: NotRequired[builtins.list[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]]
+    device_platform_exclude: NotRequired[builtins.list[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]]
+    device_type: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    device_type_exclude: NotRequired[builtins.list[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]]
+    browser: NotRequired[builtins.list[Literal['chrome', 'safari', 'firefox', 'edge', 'opera', 'samsung_internet', 'android_webview', 'other', 'unknown']]]
+    browser_exclude: NotRequired[builtins.list[Literal['chrome', 'safari', 'firefox', 'edge', 'opera', 'samsung_internet', 'android_webview', 'other', 'unknown']]]
+    store_catchments: NotRequired[builtins.list[_ExternalCoreTargetingStoreCatchmentsItem]]
+    geo_proximity: NotRequired[builtins.list[_ExternalCoreTargetingGeoProximityItemVariant1 | _ExternalCoreTargetingGeoProximityItemVariant2 | _ExternalCoreTargetingGeoProximityItemVariant3]]
+    language: NotRequired[builtins.list[builtins.str]]
+    keyword_targets: NotRequired[builtins.list[_ExternalCoreTargetingKeywordTargetsItem]]
+    negative_keywords: NotRequired[builtins.list[_ExternalCoreTargetingNegativeKeywordsItem]]
+
+class _ExternalCoreTargetingOverlayRequirements(TypedDict, total=False):
+    geo_countries: NotRequired[Literal[True]]
+    geo_countries_exclude: NotRequired[Literal[True]]
+    geo_regions: NotRequired[Literal[True] | _ExternalCoreGeoRegionRequirement]
+    geo_regions_exclude: NotRequired[Literal[True] | _ExternalCoreGeoRegionRequirement]
+    geo_metros: NotRequired[Literal[True] | _MetroRequirementVariant2]
+    geo_metros_exclude: NotRequired[Literal[True] | _MetroRequirementVariant2]
+    geo_places: NotRequired[_ExternalCoreGeoPlaceRequirement]
+    geo_places_exclude: NotRequired[_ExternalCoreGeoPlaceRequirement]
+    geo_postal_areas: NotRequired[Literal[True] | _ExternalCorePositivePostalAreaSupport]
+    geo_postal_areas_exclude: NotRequired[Literal[True] | _ExternalCorePositivePostalAreaSupport]
+    geo_proximity: NotRequired[Literal[True] | _ExternalCoreTargetingOverlayRequirementsGeoProximityVariant2]
+    daypart_targets: NotRequired[Literal[True]]
+    audience_include: NotRequired[Literal[True]]
+    audience_exclude: NotRequired[Literal[True]]
+    signal_targeting_groups: NotRequired[Literal[True]]
+    demographics: NotRequired[Literal[True] | _ExternalCoreTargetingOverlayRequirementsDemographicsVariant2]
+    frequency_cap: NotRequired[Literal[True]]
+    property_list: NotRequired[Literal[True]]
+    property_list_exclude: NotRequired[Literal[True]]
+    collection_list: NotRequired[Literal[True]]
+    collection_list_exclude: NotRequired[Literal[True]]
+    placement_selection: NotRequired[Literal[True]]
+    age_restriction: NotRequired[Literal[True]]
+    device_platform: NotRequired[Literal[True]]
+    device_platform_exclude: NotRequired[Literal[True]]
+    device_type: NotRequired[Literal[True]]
+    device_type_exclude: NotRequired[Literal[True]]
+    browser: NotRequired[Literal[True] | _BrowserRequirementVariant2]
+    browser_exclude: NotRequired[Literal[True] | _BrowserRequirementVariant2]
+    store_catchments: NotRequired[Literal[True]]
+    language: NotRequired[Literal[True]]
+    keyword_targets: NotRequired[Literal[True] | _KeywordRequirementVariant2]
+    negative_keywords: NotRequired[Literal[True] | _KeywordRequirementVariant2]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePropertyListRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _GetProductsRequestTimeBudget(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyGetProductsTargetingResolution(TypedDict, total=False):
+    brief_targeting: Required[_ExternalCoreTargeting]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    allocations: Required[builtins.list[_ExternalCoreProductAllocation]]
+    budget_allocation: NotRequired[_ExternalCoreProposalBudgetAllocationVariant1 | _ExternalCoreProposalBudgetAllocationVariant2]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    proposal_status: NotRequired[Literal['draft', 'committed', 'accepted']]
+    expires_at: NotRequired[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+    total_budget_guidance: NotRequired[_ExternalCoreProposalTotalBudgetGuidance]
+    brief_alignment: NotRequired[builtins.str]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetProductsResponseRefinementAppliedItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['request']]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseRefinementAppliedItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    product_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseRefinementAppliedItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['proposal']]
+    proposal_id: Required[builtins.str]
+    status: Required[Literal['applied', 'partial', 'unable']]
+    notes: NotRequired[builtins.str]
+
+class _GetProductsResponseIncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['products', 'pricing', 'forecast', 'proposals', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_GetProductsResponseIncompleteItemEstimatedWait]
+
+class _GetProductsResponseFilterDiagnostics(TypedDict, total=False):
+    semantics: NotRequired[Literal['only', 'any', 'approximate']]
+    total_candidates: NotRequired[builtins.int]
+    excluded_by: NotRequired[builtins.dict[builtins.str, _GetProductsResponseFilterDiagnosticsExcludedByValue]]
+
+class _GetPropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetPropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetPropertyListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _ExternalCoreIdentifier(TypedDict, total=False):
+    type: Required[Literal['domain', 'subdomain', 'network_id', 'ios_bundle', 'android_package', 'apple_app_store_id', 'google_play_id', 'roku_store_id', 'fire_tv_asin', 'samsung_app_id', 'apple_tv_bundle', 'bundle_id', 'venue_id', 'screen_id', 'openooh_venue_type', 'rss_url', 'apple_podcast_id', 'spotify_collection_id', 'podcast_guid', 'station_id', 'facility_id']]
+    value: Required[builtins.str]
+
+class _GetRightsResponseRightsItem(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    brand_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    match_score: NotRequired[builtins.float]
+    match_reasons: NotRequired[builtins.list[builtins.str]]
+    available_uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    exclusivity_status: NotRequired[_GetRightsResponseRightsItemExclusivityStatus]
+    pricing_options: Required[builtins.list[_ExternalBrandRightsPricingOption]]
+    content_restrictions: NotRequired[builtins.list[builtins.str]]
+    preview_assets: NotRequired[builtins.list[_GetRightsResponseRightsItemPreviewAssetsItem]]
+
+class _GetRightsResponseExcludedItem(TypedDict, total=False):
+    brand_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    reason: Required[builtins.str]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetSignalsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetSignalsRequestSignalRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsRequestSignalRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsRequestSignalRefsItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsRequestSignalIdsItemVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsRequestSignalIdsItemVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsRequestDestinationsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _GetSignalsRequestDestinationsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+
+class _ExternalCoreSignalFilters(TypedDict, total=False):
+    catalog_types: NotRequired[builtins.list[Literal['marketplace', 'custom', 'owned']]]
+    data_providers: NotRequired[builtins.list[builtins.str]]
+    max_cpm: NotRequired[builtins.float]
+    max_percent: NotRequired[builtins.float]
+    min_coverage_percentage: NotRequired[builtins.float]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItem(TypedDict, total=False):
+    signal_ref: NotRequired[_GetSignalsResponseSignalsItemSignalRefVariant1 | _GetSignalsResponseSignalsItemSignalRefVariant2 | _GetSignalsResponseSignalsItemSignalRefVariant3 | _GetSignalsResponseSignalsItemSignalRefVariant4 | _GetSignalsResponseSignalsItemSignalRefVariant5 | _GetSignalsResponseSignalsItemSignalRefVariant6 | _GetSignalsResponseSignalsItemSignalRefVariant7 | _GetSignalsResponseSignalsItemSignalRefVariant8 | _GetSignalsResponseSignalsItemSignalRefVariant9]
+    signal_id: NotRequired[_GetSignalsResponseSignalsItemSignalIdVariant1 | _GetSignalsResponseSignalsItemSignalIdVariant2]
+    name: Required[builtins.str]
+    description: Required[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_GetSignalsResponseSignalsItemRange]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    demographic_predicate: NotRequired[_GetSignalsResponseSignalsItemDemographicPredicate]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    taxonomy: NotRequired[_GetSignalsResponseSignalsItemTaxonomy]
+    segmentation_criteria: NotRequired[builtins.str]
+    criteria_url: NotRequired[builtins.str]
+    data_sources: NotRequired[builtins.list[Literal['app_behavior', 'app_usage', 'web_usage', 'geo_location', 'email', 'tv_ott_or_stb_device', 'panel', 'online_ecommerce', 'credit_data', 'loyalty_card', 'transaction', 'online_survey', 'offline_survey', 'public_record_census', 'public_record_voter_file', 'public_record_other', 'offline_transaction']]]
+    methodology: NotRequired[Literal['observed', 'declared', 'derived', 'inferred', 'modeled']]
+    audience_expansion: NotRequired[builtins.bool]
+    device_expansion: NotRequired[builtins.bool]
+    refresh_cadence: NotRequired[Literal['intra_day', 'daily', 'weekly', 'monthly', 'bi_monthly', 'quarterly', 'bi_annually', 'annually']]
+    lookback_window: NotRequired[Literal['intra_day', 'daily', 'weekly', 'monthly', 'bi_monthly', 'quarterly', 'bi_annually', 'annually']]
+    onboarder: NotRequired[_GetSignalsResponseSignalsItemOnboarder]
+    countries: NotRequired[builtins.list[builtins.str]]
+    consent_basis: NotRequired[builtins.list[Literal['consent', 'legitimate_interest', 'contract', 'legal_obligation']]]
+    art9_basis: NotRequired[Literal['explicit_consent', 'manifestly_made_public', 'substantial_public_interest', 'vital_interests']]
+    modeling: NotRequired[_GetSignalsResponseSignalsItemModeling]
+    data_subject_rights: NotRequired[_GetSignalsResponseSignalsItemDataSubjectRights]
+    dts_compliant_version: NotRequired[builtins.str]
+    signal_agent_segment_id: Required[builtins.str]
+    signal_type: Required[Literal['marketplace', 'custom', 'owned']]
+    data_provider: NotRequired[builtins.str]
+    coverage_percentage: NotRequired[builtins.float]
+    coverage_forecast: NotRequired[_ExternalCoreSignalCoverageForecast]
+    deployments: Required[builtins.list[_GetSignalsResponseSignalsItemDeploymentsItemVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_GetSignalsResponseSignalsItemPricingOptionsItemVariant1 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant2 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant3 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant4 | _GetSignalsResponseSignalsItemPricingOptionsItemVariant5]]
+
+class _GetSignalsResponseIncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['signals', 'pricing', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_GetSignalsResponseIncompleteItemEstimatedWait]
+
+class _GetTaskStatusRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _GetTaskStatusRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _GetTaskStatusResponseProgress(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+
+class _GetTaskStatusResponseError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    details: NotRequired[_GetTaskStatusResponseErrorDetails]
+
+class _GetTaskStatusResponseHistoryItem(TypedDict, total=False):
+    timestamp: Required[builtins.str]
+    type: Required[Literal['request', 'response']]
+    data: Required[builtins.dict[builtins.str, Any]]
+
+class _IdentityMatchRequestIdentitiesItem(TypedDict, total=False):
+    user_token: Required[builtins.str]
+    uid_type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]
+    attestation: NotRequired[_IdentityMatchRequestIdentitiesItemAttestation]
+
+class _IdentityMatchRequestConsent(TypedDict, total=False):
+    gdpr: NotRequired[builtins.bool]
+    tcf_consent: NotRequired[builtins.str]
+    gpp: NotRequired[builtins.str]
+    us_privacy: NotRequired[builtins.str]
+
+class _IdentityMatchRequestSealedCredentialsItem(TypedDict, total=False):
+    audience_kid: Required[builtins.str]
+    payload: Required[builtins.str]
+
+class _IdentityMatchResponseTmpxProvidersValue(TypedDict, total=False):
+    chunks: Required[builtins.list[_ExternalTrustedMatchTmpxChunk]]
+
+class _ListAccountsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListAccountsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreAccountWithAuthorization(TypedDict, total=False):
+    account_id: Required[builtins.str]
+    name: Required[builtins.str]
+    advertiser: NotRequired[builtins.str]
+    billing_proxy: NotRequired[builtins.str]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    revision: NotRequired[builtins.int]
+    identity_change: NotRequired[_ExternalCoreAccountWithAuthorizationIdentityChangeVariant1 | _ExternalCoreAccountWithAuthorizationIdentityChangeVariant2]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    destination_billing_entity: NotRequired[Any]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_ExternalCoreAccountWithAuthorizationCreditLimit]
+    setup: NotRequired[_ExternalCoreAccountWithAuthorizationSetup]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    governance_agents: NotRequired[builtins.list[_ExternalCoreAccountWithAuthorizationGovernanceAgentsItem]]
+    reporting_bucket: NotRequired[_ExternalCoreAccountWithAuthorizationReportingBucket]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_ExternalCoreNotificationConfig]]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    authorization: NotRequired[_ExternalCoreAccountAuthorization]
+
+class _ListCollectionListsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCollectionListsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalContentStandardsContentStandards(TypedDict, total=False):
+    standards_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: NotRequired[builtins.list[builtins.str]]
+    policies: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+    calibration_exemplars: NotRequired[_ExternalContentStandardsContentStandardsCalibrationExemplars]
+    pricing_options: NotRequired[builtins.list[_ExternalContentStandardsContentStandardsPricingOptionsItemVariant1 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant2 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant3 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant4 | _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativeFormatsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCreativeFormatsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreFormat(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    example_url: NotRequired[builtins.str]
+    accepts_parameters: NotRequired[builtins.list[Literal['dimensions', 'duration', 'pixel_ratio']]]
+    renders: NotRequired[builtins.list[_ExternalCoreFormatRendersItemVariant1 | _ExternalCoreFormatRendersItemVariant2]]
+    assets: NotRequired[builtins.list[_ExternalCoreFormatAssetsItemVariant1 | _ExternalCoreFormatAssetsItemVariant2 | _ExternalCoreFormatAssetsItemVariant3 | _ExternalCoreFormatAssetsItemVariant4 | _ExternalCoreFormatAssetsItemVariant5 | _ExternalCoreFormatAssetsItemVariant6 | _ExternalCoreFormatAssetsItemVariant7 | _ExternalCoreFormatAssetsItemVariant8 | _ExternalCoreFormatAssetsItemVariant9 | _ExternalCoreFormatAssetsItemVariant10 | _ExternalCoreFormatAssetsItemVariant11 | _ExternalCoreFormatAssetsItemVariant12 | _ExternalCoreFormatAssetsItemVariant13 | _ExternalCoreFormatAssetsItemVariant14 | _ExternalCoreFormatAssetsItemVariant15 | _ExternalCoreFormatAssetsItemVariant16]]
+    delivery: NotRequired[builtins.dict[builtins.str, Any]]
+    supported_macros: NotRequired[builtins.list[Literal['MEDIA_BUY_ID', 'PACKAGE_ID', 'CREATIVE_ID', 'CACHEBUSTER', 'TIMESTAMP', 'CLICK_URL', 'GDPR', 'GDPR_CONSENT', 'US_PRIVACY', 'GPP_STRING', 'GPP_SID', 'IP_ADDRESS', 'LIMIT_AD_TRACKING', 'DEVICE_TYPE', 'OS', 'OS_VERSION', 'DEVICE_MAKE', 'DEVICE_MODEL', 'USER_AGENT', 'APP_BUNDLE', 'APP_NAME', 'COUNTRY', 'REGION', 'CITY', 'ZIP', 'DMA', 'LAT', 'LONG', 'DEVICE_ID', 'DEVICE_ID_TYPE', 'DOMAIN', 'PAGE_URL', 'REFERRER', 'KEYWORDS', 'PLACEMENT_ID', 'FOLD_POSITION', 'AD_WIDTH', 'AD_HEIGHT', 'VIDEO_ID', 'VIDEO_TITLE', 'VIDEO_DURATION', 'VIDEO_CATEGORY', 'CONTENT_GENRE', 'CONTENT_RATING', 'PLAYER_WIDTH', 'PLAYER_HEIGHT', 'POD_POSITION', 'POD_SIZE', 'AD_BREAK_ID', 'STATION_ID', 'COLLECTION_NAME', 'INSTALLMENT_ID', 'AUDIO_DURATION', 'TMPX', 'IMPRESSION_ID', 'AXEM', 'CATALOG_ID', 'SKU', 'GTIN', 'OFFERING_ID', 'JOB_ID', 'HOTEL_ID', 'FLIGHT_ID', 'VEHICLE_ID', 'LISTING_ID', 'STORE_ID', 'PROGRAM_ID', 'DESTINATION_ID', 'CREATIVE_VARIANT_ID', 'APP_ITEM_ID', 'ITEM_NAME', 'ITEM_DESCRIPTION', 'ITEM_TAGLINE', 'ITEM_PRICE', 'ITEM_PRICE_CURRENCY'] | builtins.str]]
+    input_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_card: NotRequired[_ExternalCoreFormatFormatCard]
+    accessibility: NotRequired[_ExternalCoreFormatAccessibility]
+    supported_disclosure_positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    disclosure_capabilities: NotRequired[builtins.list[_ExternalCoreFormatDisclosureCapabilitiesItem]]
+    format_card_detailed: NotRequired[_ExternalCoreFormatFormatCardDetailed]
+    reported_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreFormatPricingOptionsItemVariant1 | _ExternalCoreFormatPricingOptionsItemVariant2 | _ExternalCoreFormatPricingOptionsItemVariant3 | _ExternalCoreFormatPricingOptionsItemVariant4 | _ExternalCoreFormatPricingOptionsItemVariant5]]
+    canonical: NotRequired[_ExternalCoreCanonicalProjectionRef]
+    canonical_parameters: NotRequired[_ExternalCoreFormatCanonicalParametersVariant1 | _ExternalCoreFormatCanonicalParametersVariant2 | _ExternalCoreFormatCanonicalParametersVariant3 | _ExternalCoreFormatCanonicalParametersVariant4 | _ExternalCoreFormatCanonicalParametersVariant5 | _ExternalCoreFormatCanonicalParametersVariant6 | _ExternalCoreFormatCanonicalParametersVariant7 | _ExternalCoreFormatCanonicalParametersVariant8 | _ExternalCoreFormatCanonicalParametersVariant9 | _ExternalCoreFormatCanonicalParametersVariant10 | _ExternalCoreFormatCanonicalParametersVariant11 | _ExternalCoreFormatCanonicalParametersVariant12 | _ExternalCoreFormatCanonicalParametersVariant13]
+
+class _ListCreativeFormatsResponseCreativeAgentsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    agent_name: NotRequired[builtins.str]
+    capabilities: NotRequired[builtins.list[Literal['validation', 'assembly', 'generation', 'preview', 'delivery']]]
+
+class _ExternalCoreCreativeFilters(TypedDict, total=False):
+    accounts: NotRequired[builtins.list[_ExternalCoreCreativeFiltersAccountsItemVariant1 | _ExternalCoreCreativeFiltersAccountsItemVariant2]]
+    statuses: NotRequired[builtins.list[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    tags_any: NotRequired[builtins.list[builtins.str]]
+    name_contains: NotRequired[builtins.str]
+    creative_ids: NotRequired[builtins.list[builtins.str]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    assigned_to_packages: NotRequired[builtins.list[builtins.str]]
+    media_buy_ids: NotRequired[builtins.list[builtins.str]]
+    unassigned: NotRequired[builtins.bool]
+    has_served: NotRequired[builtins.bool]
+    indicator_types: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    concept_ids: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_kinds: NotRequired[builtins.list[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]]
+    asset_types: NotRequired[builtins.list[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'zip', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']]]
+    has_variables: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_date', 'updated_date', 'name', 'status', 'assignment_count']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListCreativesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListCreativesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListCreativesResponseQuerySummary(TypedDict, total=False):
+    total_matching: Required[builtins.int]
+    returned: Required[builtins.int]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_ListCreativesResponseQuerySummarySortApplied]
+
+class _ListCreativesResponseCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant1 | _ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant2]
+    status: Required[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    created_date: Required[builtins.str]
+    updated_date: Required[builtins.str]
+    assets: NotRequired[builtins.dict[builtins.str, Any]]
+    localization: NotRequired[_ExternalCoreCreativeLocalizationReadback]
+    localization_unavailable: NotRequired[_ListCreativesResponseCreativesItemVariant1LocalizationUnavailable]
+    tags: NotRequired[builtins.list[builtins.str]]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    rights_attestation_evaluations: NotRequired[builtins.list[_ExternalCoreRightsAttestationEvaluation]]
+    concept_id: NotRequired[builtins.str]
+    concept_name: NotRequired[builtins.str]
+    variables: NotRequired[builtins.list[_ExternalCoreCreativeVariable]]
+    assignments: NotRequired[_ListCreativesResponseCreativesItemVariant1Assignments]
+    snapshot: NotRequired[_ListCreativesResponseCreativesItemVariant1Snapshot]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    items: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant1ItemsItemVariant1 | _ListCreativesResponseCreativesItemVariant1ItemsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant1 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant2 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant3 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant4 | _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5]]
+    purge: NotRequired[_ListCreativesResponseCreativesItemVariant1Purge]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+
+class _ListCreativesResponseCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant1 | _ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant2]
+    status: Required[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    created_date: Required[builtins.str]
+    updated_date: Required[builtins.str]
+    assets: NotRequired[builtins.dict[builtins.str, Any]]
+    localization: NotRequired[_ExternalCoreCreativeLocalizationReadback]
+    localization_unavailable: NotRequired[_ListCreativesResponseCreativesItemVariant2LocalizationUnavailable]
+    tags: NotRequired[builtins.list[builtins.str]]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    rights_attestation_evaluations: NotRequired[builtins.list[_ExternalCoreRightsAttestationEvaluation]]
+    concept_id: NotRequired[builtins.str]
+    concept_name: NotRequired[builtins.str]
+    variables: NotRequired[builtins.list[_ExternalCoreCreativeVariable]]
+    assignments: NotRequired[_ListCreativesResponseCreativesItemVariant2Assignments]
+    snapshot: NotRequired[_ListCreativesResponseCreativesItemVariant2Snapshot]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    items: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant2ItemsItemVariant1 | _ListCreativesResponseCreativesItemVariant2ItemsItemVariant2]]
+    pricing_options: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant1 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant2 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant3 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant4 | _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5]]
+    purge: NotRequired[_ListCreativesResponseCreativesItemVariant2Purge]
+    webhook_activity: NotRequired[builtins.list[_ExternalCoreWebhookActivityRecord]]
+
+class _ListCreativesResponseStatusSummary(TypedDict, total=False):
+    processing: NotRequired[builtins.int]
+    approved: NotRequired[builtins.int]
+    pending_review: NotRequired[builtins.int]
+    rejected: NotRequired[builtins.int]
+    archived: NotRequired[builtins.int]
+
+class _ListProductsRequestPushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_ListProductsRequestPushNotificationConfigAuthentication]
+
+class _ExternalMediaBuyProductDiscoveryCriteria(TypedDict, total=False):
+    product_ids: NotRequired[builtins.list[builtins.str]]
+    offer_filters: NotRequired[_ExternalCoreProductOfferFilters]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    required_overlay_support: NotRequired[_ExternalCoreTargetingOverlayRequirements]
+    catalog: NotRequired[_ExternalCoreCatalogSelection]
+    policy_ids: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalProduct(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    publisher_properties: NotRequired[builtins.list[_ExternalCoreCanonicalProductPublisherPropertiesItemVariant1 | _ExternalCoreCanonicalProductPublisherPropertiesItemVariant2 | _ExternalCoreCanonicalProductPublisherPropertiesItemVariant3]]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    format_options: NotRequired[builtins.list[_ExternalCoreCanonicalFormatOption]]
+    placements: NotRequired[builtins.list[_ExternalCoreCanonicalPlacement]]
+    delivery_type: NotRequired[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreCanonicalPricingOption]]
+    forecast: NotRequired[_ExternalCoreCanonicalDeliveryForecast]
+    reporting_capabilities: NotRequired[_ExternalCoreCanonicalReportingCapabilities]
+    measurement_terms: NotRequired[_ExternalCoreCanonicalMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCoreCanonicalPerformanceStandard]]
+    catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    signal_targeting_allowed: NotRequired[builtins.bool]
+    signal_targeting_rules: NotRequired[_ExternalCoreSignalTargetingRules]
+    demographic_targeting: NotRequired[_ExternalCoreDemographicTargetingCapability]
+    audience_evidence: NotRequired[builtins.list[_ExternalCoreCanonicalAudienceEvidence]]
+    audience_evidence_selections: NotRequired[builtins.list[_ExternalCoreCanonicalAudienceEvidenceSelection]]
+    max_optimization_goals: NotRequired[builtins.int]
+    catalog_match: NotRequired[_ExternalCoreCanonicalProductCatalogMatch]
+    brief_relevance: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    allowed_actions: NotRequired[builtins.list[_ExternalCoreCanonicalProductAction]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListProductsResponseIncompleteItem(TypedDict, total=False):
+    scope: Required[Literal['products', 'pricing', 'forecast', 'wholesale_feed']]
+    description: Required[builtins.str]
+    estimated_wait: NotRequired[_ExternalCoreDuration]
+
+class _ListPropertyListsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListPropertyListsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListTasksRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListTasksRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListTasksRequestFilters(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    protocols: NotRequired[builtins.list[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]]
+    status: NotRequired[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    statuses: NotRequired[builtins.list[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]]
+    task_type: NotRequired[Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']]
+    task_types: NotRequired[builtins.list[Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    task_ids: NotRequired[builtins.list[builtins.str]]
+    context_contains: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _ListTasksRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_at', 'updated_at', 'status', 'task_type', 'protocol']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListTasksResponseQuerySummary(TypedDict, total=False):
+    total_matching: NotRequired[builtins.int]
+    returned: NotRequired[builtins.int]
+    domain_breakdown: NotRequired[_ListTasksResponseQuerySummaryDomainBreakdown]
+    status_breakdown: NotRequired[builtins.dict[builtins.str, builtins.int]]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_ListTasksResponseQuerySummarySortApplied]
+
+class _ListTasksResponseTasksItem(TypedDict, total=False):
+    task_id: Required[builtins.str]
+    task_type: Required[Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']]
+    domain: Required[Literal['media-buy', 'signals', 'creative']]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    created_at: Required[builtins.str]
+    updated_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _ListTransformersRequestExpandPaginationItem(TypedDict, total=False):
+    transformer_id: Required[builtins.str]
+    field: Required[builtins.str]
+    options_cursor: Required[builtins.str]
+
+class _ListTransformersRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ListTransformersRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformer(TypedDict, total=False):
+    transformer_id: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    metadata: NotRequired[builtins.dict[builtins.str, Any]]
+    voice_synthesis_ref: NotRequired[builtins.list[_ExternalCoreTransformerVoiceSynthesisRefItem]]
+    input_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    input_formats: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1 | _ExternalCoreTransformerInputFormatsItemVariant2 | _ExternalCoreTransformerInputFormatsItemVariant3 | _ExternalCoreTransformerInputFormatsItemVariant4 | _ExternalCoreTransformerInputFormatsItemVariant5 | _ExternalCoreTransformerInputFormatsItemVariant6 | _ExternalCoreTransformerInputFormatsItemVariant7 | _ExternalCoreTransformerInputFormatsItemVariant8 | _ExternalCoreTransformerInputFormatsItemVariant9 | _ExternalCoreTransformerInputFormatsItemVariant10 | _ExternalCoreTransformerInputFormatsItemVariant11 | _ExternalCoreTransformerInputFormatsItemVariant12 | _ExternalCoreTransformerInputFormatsItemVariant13]]
+    output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    params: NotRequired[builtins.list[_ExternalCoreTransformerParam]]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreTransformerPricingOptionsItemVariant1 | _ExternalCoreTransformerPricingOptionsItemVariant2 | _ExternalCoreTransformerPricingOptionsItemVariant3 | _ExternalCoreTransformerPricingOptionsItemVariant4 | _ExternalCoreTransformerPricingOptionsItemVariant5]]
+    multiplicity: NotRequired[_ExternalCoreTransformerMultiplicity]
+
+class _ExternalCoreEvent(TypedDict, total=False):
+    event_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_time: Required[builtins.str]
+    user_match: NotRequired[_ExternalCoreUserMatch]
+    custom_data: NotRequired[_ExternalCoreEventCustomData]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    surface: NotRequired[_ExternalCoreEventSurface]
+    event_source_url: NotRequired[builtins.str]
+    custom_event_name: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _LogEventResponsePartialFailuresItem(TypedDict, total=False):
+    event_id: Required[builtins.str]
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+
+class _MediaBuyCommitmentResponseAcceptedProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: NotRequired[builtins.str]
+    media_buy_id: Required[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['accepted']]
+    accepted_at: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _MediaBuyCommitmentResponsePurchaseBindingsItem(TypedDict, total=False):
+    purchase_index: Required[builtins.int]
+    product_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+
+class _MediaBuyCommitmentResponseAvailableActionsItemVariant1(TypedDict, total=False):
+    task: Required[Literal['control_media_buy']]
+    action: Required[Literal['pause', 'resume', 'cancel', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'update_catalog_assignments', 'update_keywords', 'update_optimization_goals', 'update_impression_goal', 'update_spend_target', 'update_reporting_webhook', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _MediaBuyCommitmentResponseAvailableActionsItemVariant2(TypedDict, total=False):
+    task: Required[Literal['refine_proposals']]
+    action: Required[Literal['cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'add_packages', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _MediaBuyCommitmentResponseAvailableActionsItemVariant3(TypedDict, total=False):
+    task: Required[Literal['sync_creatives']]
+    action: Required[Literal['replace_creative', 'update_creative_assignments', 'remove_creative']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _MediaBuyCommitmentResponseWarningsItem(TypedDict, total=False):
+    code: Required[Literal['inventory_shortfall_forecast', 'flight_change_creates_pacing_risk']]
+    message: Required[builtins.str]
+    affected_resource: Required[_ExternalCoreWarningResource]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PackageRequestFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PackageRequestFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PackageRequestBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_PackageRequestBiddingCostPer]
+    roas: NotRequired[_PackageRequestBiddingRoas]
+
+class _PackageRequestOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_PackageRequestOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant1TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _PackageRequestOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_PackageRequestOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant2TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant2TargetVariant2 | _PackageRequestOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _PackageRequestOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_PackageRequestOptimizationGoalsItemVariant3TargetVariant1 | _PackageRequestOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreAudienceEvidenceRequirements(TypedDict, total=False):
+    requirement_mode: Required[Literal['required', 'preferred']]
+    evidence_presence: Required[Literal['required', 'when_available']]
+    accepted_methodologies: NotRequired[builtins.list[Literal['observed', 'declared', 'derived', 'inferred', 'modeled', 'projected']]]
+    excluded_methodologies: NotRequired[builtins.list[Literal['observed', 'declared', 'derived', 'inferred', 'modeled', 'projected']]]
+    accepted_evidence_types: NotRequired[builtins.list[Literal['measured', 'forecast', 'seller_declared']]]
+    accepted_providers: NotRequired[builtins.list[_ExternalCoreBrandRef]]
+    excluded_providers: NotRequired[builtins.list[_ExternalCoreBrandRef]]
+    accepted_subject_types: NotRequired[builtins.list[Literal['individual', 'household', 'business', 'contextual', 'none']]]
+    accepted_resolution_methods: NotRequired[builtins.list[Literal['deterministic_id', 'probabilistic_device', 'browser', 'geographic', 'content_signal', 'mixed']]]
+    minimum_confidence: NotRequired[builtins.float]
+    maximum_age: NotRequired[_ExternalCoreAudienceEvidenceRequirementsMaximumAge]
+    methodology_documentation_required: NotRequired[builtins.bool]
+    independent_attestation_required: NotRequired[builtins.bool]
+    accepted_attestation_issuers: NotRequired[builtins.list[_ExternalCoreAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant1 | _ExternalCoreAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant2 | _ExternalCoreAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant3]]
+    accepted_attestation_claim_types: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidencePin(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    snapshot_id: Required[builtins.str]
+    version: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_ExternalCoreMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_ExternalCoreMeasurementTermsMakegoodPolicy]
+
+class _ExternalCorePerformanceStandard(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_ExternalCoreBrandRef]
+
+class _PackageRequestCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_PackageRequestCommittedMetricsItemVariant1Qualifier]
+
+class _PackageRequestCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreCreativeAssignment(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    rotation_mode: NotRequired[Literal['weighted', 'even', 'sequential', 'random']]
+    group_id: NotRequired[builtins.str]
+    sequence_position: NotRequired[builtins.int]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _PackageRequestCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PackageRequestCreativesItemVariant1FormatOptionRefVariant1 | _PackageRequestCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_PackageRequestCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+
+class _PackageRequestCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PackageRequestCreativesItemVariant2FormatOptionRefVariant1 | _PackageRequestCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_PackageRequestCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+
+class _PreviewCreativeRequestCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1 | _PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1 | _PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeRequestRequestsItem(TypedDict, total=False):
+    target_capability_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    creative_manifest: NotRequired[_PreviewCreativeRequestRequestsItemCreativeManifestVariant1 | _PreviewCreativeRequestRequestsItemCreativeManifestVariant2]
+    creative_id: NotRequired[builtins.str]
+    inputs: NotRequired[builtins.list[_PreviewCreativeRequestRequestsItemInputsItem]]
+    template_id: NotRequired[builtins.str]
+    quality: NotRequired[Literal['draft', 'production']]
+    output_format: NotRequired[Literal['url', 'html']]
+    item_limit: NotRequired[builtins.int]
+
+class _PreviewCreativeResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponsePreviewsItemInput]
+
+class _PreviewCreativeResponseResultsItemVariant1(TypedDict, total=False):
+    success: Required[Literal[True]]
+    creative_id: Required[builtins.str]
+    quality_used: NotRequired[Literal['draft', 'production']]
+    response: Required[_PreviewCreativeResponseResultsItemVariant1Response]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _PreviewCreativeResponseResultsItemVariant2(TypedDict, total=False):
+    success: Required[Literal[False]]
+    creative_id: Required[builtins.str]
+    quality_used: NotRequired[Literal['draft', 'production']]
+    response: NotRequired[_PreviewCreativeResponseResultsItemVariant2Response]
+    errors: Required[builtins.list[_ExternalCoreError]]
+
+class _PreviewCreativeResponsePreviewsItem2(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1 | _PreviewCreativeResponsePreviewsItem2RendersItemVariant2 | _PreviewCreativeResponsePreviewsItem2RendersItemVariant3]]
+
+class _PreviewCreativeResponseManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeResponseManifestVariant1FormatOptionRefVariant1 | _PreviewCreativeResponseManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeResponseManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeResponseManifestVariant2FormatOptionRefVariant1 | _PreviewCreativeResponseManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDatetimeRange(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ProvidePerformanceFeedbackRequestMetricVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_ProvidePerformanceFeedbackRequestMetricVariant1Qualifier]
+
+class _ProvidePerformanceFeedbackRequestMetricVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ProvidePerformanceFeedbackRequestEvidence(TypedDict, total=False):
+    sample_size: NotRequired[builtins.int]
+    confidence_interval: NotRequired[_ProvidePerformanceFeedbackRequestEvidenceConfidenceInterval]
+
+class _ProviderContextMatchResponseSignals(TypedDict, total=False):
+    segments: NotRequired[builtins.list[builtins.str]]
+    targeting_kvs: NotRequired[builtins.list[_TargetingKvs2Item]]
+
+class _ExternalTrustedMatchTmpxChunk(TypedDict, total=False):
+    slot_id: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _RefineProposalsRequestPushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_RefineProposalsRequestPushNotificationConfigAuthentication]
+
+class _RefineProposalsRequestRefinementsItemVariant1(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    action: Required[Literal['finalize']]
+    change_kind: NotRequired[Literal['amendment', 'cancellation']]
+    constraints: NotRequired[_RefineProposalsRequestRefinementsItemVariant1Constraints]
+    product_changes: NotRequired[builtins.dict[builtins.str, Literal['include', 'omit']]]
+    alternatives: NotRequired[_RefineProposalsRequestRefinementsItemVariant1Alternatives]
+    ask: NotRequired[builtins.str]
+    criteria: NotRequired[_ExternalMediaBuyProductDiscoveryCriteria]
+
+class _RefineProposalsRequestRefinementsItemVariant2(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    action: Required[Literal['revise']]
+    change_kind: NotRequired[Literal['amendment', 'cancellation']]
+    constraints: NotRequired[_RefineProposalsRequestRefinementsItemVariant2Constraints]
+    product_changes: NotRequired[builtins.dict[builtins.str, Literal['include', 'omit']]]
+    alternatives: NotRequired[_RefineProposalsRequestRefinementsItemVariant2Alternatives]
+    ask: NotRequired[builtins.str]
+    criteria: NotRequired[_ExternalMediaBuyProductDiscoveryCriteria]
+
+class _RefineProposalsResponseResultsItemVariant1(TypedDict, total=False):
+    source_proposal_id: Required[builtins.str]
+    outcome: Required[Literal['revised']]
+    proposal: NotRequired[_ExternalCoreCanonicalProposal]
+    proposals: Required[builtins.list[_ExternalCoreCanonicalProposal]]
+    reason_code: NotRequired[Literal['commercially_declined', 'constraint_unsatisfiable', 'unsupported_dimension', 'uninterpreted', 'alternatives_unavailable', 'source_unavailable', 'hold_unavailable', 'batch_aborted']]
+    reason: NotRequired[builtins.str]
+    unsatisfied_constraints: NotRequired[builtins.list[builtins.str]]
+    unsatisfied_product_changes: NotRequired[builtins.dict[builtins.str, Any]]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+    targeting_resolution: NotRequired[_ExternalMediaBuyGetProductsTargetingResolution]
+
+class _RefineProposalsResponseResultsItemVariant2(TypedDict, total=False):
+    source_proposal_id: Required[builtins.str]
+    outcome: Required[Literal['partial']]
+    proposal: NotRequired[_ExternalCoreCanonicalProposal]
+    proposals: Required[builtins.list[_ExternalCoreCanonicalProposal]]
+    reason_code: Required[Literal['commercially_declined', 'constraint_unsatisfiable', 'unsupported_dimension', 'uninterpreted', 'alternatives_unavailable', 'source_unavailable', 'hold_unavailable', 'batch_aborted']]
+    reason: Required[builtins.str]
+    unsatisfied_constraints: NotRequired[builtins.list[builtins.str]]
+    unsatisfied_product_changes: NotRequired[builtins.dict[builtins.str, Any]]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+    targeting_resolution: NotRequired[_ExternalMediaBuyGetProductsTargetingResolution]
+
+class _RefineProposalsResponseResultsItemVariant3(TypedDict, total=False):
+    source_proposal_id: Required[builtins.str]
+    outcome: Required[Literal['finalized']]
+    proposal: Required[_RefineProposalsResponseResultsItemVariant3Proposal]
+    proposals: NotRequired[builtins.list[_ExternalCoreCanonicalProposal]]
+    reason_code: NotRequired[Literal['commercially_declined', 'constraint_unsatisfiable', 'unsupported_dimension', 'uninterpreted', 'alternatives_unavailable', 'source_unavailable', 'hold_unavailable', 'batch_aborted']]
+    reason: NotRequired[builtins.str]
+    unsatisfied_constraints: NotRequired[builtins.list[builtins.str]]
+    unsatisfied_product_changes: NotRequired[builtins.dict[builtins.str, Any]]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+    targeting_resolution: NotRequired[_ExternalMediaBuyGetProductsTargetingResolution]
+
+class _RefineProposalsResponseResultsItemVariant4(TypedDict, total=False):
+    source_proposal_id: Required[builtins.str]
+    outcome: Required[Literal['unable']]
+    proposal: NotRequired[_ExternalCoreCanonicalProposal]
+    proposals: NotRequired[builtins.list[_ExternalCoreCanonicalProposal]]
+    reason_code: Required[Literal['commercially_declined', 'constraint_unsatisfiable', 'unsupported_dimension', 'uninterpreted', 'alternatives_unavailable', 'source_unavailable', 'hold_unavailable', 'batch_aborted']]
+    reason: Required[builtins.str]
+    unsatisfied_constraints: NotRequired[builtins.list[builtins.str]]
+    unsatisfied_product_changes: NotRequired[builtins.dict[builtins.str, Any]]
+    suggestions: NotRequired[builtins.list[builtins.str]]
+    targeting_resolution: NotRequired[_ExternalMediaBuyGetProductsTargetingResolution]
+
+class _ReportPlanAdjustmentRequestAmount(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ReportPlanAdjustmentRequestEvidence(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    evidence_type: Required[Literal['decommitment_agreement', 'refund_settlement', 'credit_note', 'makegood_agreement']]
+    digest: Required[builtins.str]
+    issued_at: Required[builtins.str]
+
+class _ReportPlanAdjustmentResponseAmount(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ReportPlanAdjustmentResponsePlanSummary(TypedDict, total=False):
+    accounting_mode: Required[Literal['gross_commitment', 'verified_net_cost']]
+    gross_committed: Required[builtins.float]
+    adjustments_reported: Required[builtins.float]
+    adjustments_verified: Required[builtins.float]
+    net_cost: Required[builtins.float]
+    headroom_restored: Required[builtins.float]
+    ledger_committed: Required[builtins.float]
+    net_committed: Required[builtins.float]
+    budget_remaining: Required[builtins.float]
+
+class _ReportPlanOutcomeRequestSellerResponse(TypedDict, total=False):
+    seller_reference: NotRequired[builtins.str]
+    committed_budget: NotRequired[builtins.float]
+    packages: NotRequired[builtins.list[_ReportPlanOutcomeRequestSellerResponsePackagesItem]]
+    planned_delivery: NotRequired[_ExternalCorePlannedDelivery]
+    creative_deadline: NotRequired[builtins.str]
+
+class _ReportPlanOutcomeRequestDelivery(TypedDict, total=False):
+    observation_id: Required[builtins.str]
+    source: Required[Literal['seller_statement_copy', 'buyer_measurement']]
+    observed_at: Required[builtins.str]
+    seller_statement_id: NotRequired[builtins.str]
+    seller_statement_digest: NotRequired[builtins.str]
+    reporting_period: Required[_ReportPlanOutcomeRequestDeliveryReportingPeriod]
+    cumulative_spend: Required[builtins.float]
+    currency: Required[builtins.str]
+    period_closed: NotRequired[builtins.bool]
+    impressions: NotRequired[builtins.int]
+
+class _ReportPlanOutcomeRequestError(TypedDict, total=False):
+    code: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+
+class _ReportPlanOutcomeResponseFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ReportPlanOutcomeResponsePlanSummary(TypedDict, total=False):
+    total_committed: NotRequired[builtins.float]
+    budget_remaining: NotRequired[builtins.float]
+
+class _ReportUsageRequestUsageItem(TypedDict, total=False):
+    account: Required[_ReportUsageRequestUsageItemAccountVariant1 | _ReportUsageRequestUsageItemAccountVariant2]
+    media_buy_id: NotRequired[builtins.str]
+    vendor_cost: Required[builtins.float]
+    currency: Required[builtins.str]
+    pricing_option_id: NotRequired[builtins.str]
+    impressions: NotRequired[builtins.int]
+    media_spend: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    standards_id: NotRequired[builtins.str]
+    rights_id: NotRequired[builtins.str]
+    creative_id: NotRequired[builtins.str]
+    build_variant_id: NotRequired[builtins.str]
+    property_list_id: NotRequired[builtins.str]
+    final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    measurement_window: NotRequired[builtins.str]
+
+class _RequestProposalsRequestPushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_RequestProposalsRequestPushNotificationConfigAuthentication]
+
+class _RequestProposalsRequestOpportunity(TypedDict, total=False):
+    opportunity_id: Required[builtins.str]
+    phase: NotRequired[Literal['exploratory', 'planning', 'active_sourcing']]
+    intent: NotRequired[Literal['test', 'speculative', 'planning', 'live_rfp']]
+    planning_horizon: NotRequired[_ExternalCoreDateRange]
+    response_deadline: NotRequired[builtins.str]
+    status: NotRequired[Literal['open']]
+    close_reason: NotRequired[Literal['accepted_with_seller', 'purchased_elsewhere', 'selected_alternative', 'not_pursued', 'budget_changed', 'timing_changed', 'other']]
+    close_detail: NotRequired[builtins.str]
+
+class _RequestProposalsResponseProposalsItem(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: NotRequired[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['draft']]
+    accepted_at: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _SearchBrandResult(TypedDict, total=False):
+    brand_id: Required[builtins.str]
+    house: NotRequired[_SearchBrandResultHouse]
+    relationship_trust: NotRequired[Literal['inline', 'mutual', 'leaf_only', 'house_only', 'standalone', 'unverifiable']]
+    relationship_verified_at: NotRequired[builtins.str]
+    claimed_house_domain: NotRequired[builtins.str]
+    names: Required[builtins.list[builtins.dict[builtins.str, builtins.str]]]
+    description: NotRequired[builtins.str]
+    industries: NotRequired[builtins.list[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']]]
+    keller_type: NotRequired[Literal['master', 'sub_brand', 'endorsed', 'independent']]
+    logos: NotRequired[builtins.list[_SearchBrandResultLogosItem]]
+    rights: NotRequired[_SearchBrandResultRights]
+
+class _SiGetOfferingResponseOffering(TypedDict, total=False):
+    offering_id: NotRequired[builtins.str]
+    title: NotRequired[builtins.str]
+    summary: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    availability_status: NotRequired[Literal['available', 'limited', 'sold_out', 'expired', 'region_restricted', 'inactive']]
+    price_hint: NotRequired[builtins.str]
+    image_url: NotRequired[builtins.str]
+    landing_url: NotRequired[builtins.str]
+
+class _SiGetOfferingResponseMatchingProductsItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    name: Required[builtins.str]
+    price: NotRequired[builtins.str]
+    original_price: NotRequired[builtins.str]
+    image_url: NotRequired[builtins.str]
+    availability_summary: NotRequired[builtins.str]
+    availability_status: NotRequired[Literal['available', 'limited', 'sold_out', 'expired', 'region_restricted', 'inactive']]
+    url: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContext(TypedDict, total=False):
+    paying_principal: Required[_ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipal]
+    context_use: Required[Literal['presentation_only', 'comparison_set', 'reasoning_context']]
+    disclosure_obligation: Required[_ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligation]
+    declared_at: NotRequired[builtins.str]
+    declared_by: NotRequired[_ExternalSponsoredIntelligenceSiSponsoredContextDeclaredBy]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalSponsoredIntelligenceSiIdentity(TypedDict, total=False):
+    consent_granted: Required[builtins.bool]
+    consent_timestamp: NotRequired[builtins.str]
+    consent_scope: NotRequired[builtins.list[Literal['name', 'email', 'shipping_address', 'phone', 'locale']]]
+    privacy_policy_acknowledged: NotRequired[_ExternalSponsoredIntelligenceSiIdentityPrivacyPolicyAcknowledged]
+    user: NotRequired[_ExternalSponsoredIntelligenceSiIdentityUser]
+    anonymous_session_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilities(TypedDict, total=False):
+    modalities: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesModalities]
+    components: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesComponents]
+    commerce: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesCommerce]
+    a2ui: NotRequired[_ExternalSponsoredIntelligenceSiCapabilitiesA2ui]
+    mcp_apps: NotRequired[builtins.bool]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextReceipt(TypedDict, total=False):
+    sponsored_context: Required[_ExternalSponsoredIntelligenceSiSponsoredContext]
+    host_receipt: Required[_ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceipt]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiInitiateSessionResponseResponse(TypedDict, total=False):
+    message: NotRequired[builtins.str]
+    ui_elements: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiUiElement]]
+
+class _SiSendMessageRequestActionResponse(TypedDict, total=False):
+    action: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiSendMessageResponseResponse(TypedDict, total=False):
+    message: NotRequired[builtins.str]
+    surface: NotRequired[_ExternalA2uiSurface]
+    ui_elements: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiUiElement]]
+
+class _SiSendMessageResponseHandoff(TypedDict, total=False):
+    type: NotRequired[Literal['transaction', 'complete']]
+    intent: NotRequired[_SiSendMessageResponseHandoffIntent]
+    context_for_checkout: NotRequired[_SiSendMessageResponseHandoffContextForCheckout]
+
+class _SiTerminateSessionRequestTerminationContext(TypedDict, total=False):
+    summary: NotRequired[builtins.str]
+    transaction_intent: NotRequired[_SiTerminateSessionRequestTerminationContextTransactionIntent]
+    cause: NotRequired[builtins.str]
+
+class _SiTerminateSessionResponseAcpHandoff(TypedDict, total=False):
+    checkout_url: NotRequired[builtins.str]
+    checkout_token: NotRequired[builtins.str]
+    payload: NotRequired[builtins.dict[builtins.str, Any]]
+    expires_at: NotRequired[builtins.str]
+
+class _SiTerminateSessionResponseFollowUp(TypedDict, total=False):
+    action: NotRequired[Literal['save_for_later', 'set_reminder', 'subscribe_updates', 'none']]
+    data: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _StaleResponseUpstream(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+
+class _StaleResponseOriginalError(TypedDict, total=False):
+    code: NotRequired[builtins.str]
+    message: NotRequired[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant1(TypedDict, total=False):
+    account: NotRequired[_SyncAccountsRequestAccountsItemVariant1AccountVariant1 | _SyncAccountsRequestAccountsItemVariant1AccountVariant2]
+    revision: NotRequired[builtins.int]
+    operator_identity: NotRequired[_ExternalCoreOperatorIdentity]
+    destination_billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    billing: Required[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    sandbox: NotRequired[builtins.bool]
+    preferred_reporting_protocol: NotRequired[Literal['s3', 'gcs', 'azure_blob']]
+    notification_configs: NotRequired[builtins.list[_SyncAccountsRequestAccountsItemVariant1NotificationConfigsItem]]
+
+class _SyncAccountsRequestAccountsItemVariant2(TypedDict, total=False):
+    account: Required[_SyncAccountsRequestAccountsItemVariant2AccountVariant1 | _SyncAccountsRequestAccountsItemVariant2AccountVariant2]
+    revision: NotRequired[builtins.int]
+    operator_identity: NotRequired[_ExternalCoreOperatorIdentity]
+    destination_billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    operator: NotRequired[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    sandbox: NotRequired[builtins.bool]
+    preferred_reporting_protocol: NotRequired[Literal['s3', 'gcs', 'azure_blob']]
+    notification_configs: NotRequired[builtins.list[_SyncAccountsRequestAccountsItemVariant2NotificationConfigsItem]]
+
+class _SyncAccountsResponseAccountsItem(TypedDict, total=False):
+    account_id: NotRequired[builtins.str]
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    revision: NotRequired[builtins.int]
+    identity_change: NotRequired[_SyncAccountsResponseAccountsItemIdentityChangeVariant1 | _SyncAccountsResponseAccountsItemIdentityChangeVariant2]
+    identity_change_preview: NotRequired[_SyncAccountsResponseAccountsItemIdentityChangePreviewVariant1 | _SyncAccountsResponseAccountsItemIdentityChangePreviewVariant2 | _SyncAccountsResponseAccountsItemIdentityChangePreviewVariant3]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed']]
+    status: Required[Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed']]
+    billing: NotRequired[Literal['operator', 'agent', 'advertiser']]
+    billing_entity: NotRequired[_ExternalCoreBusinessEntity]
+    destination_billing_entity: NotRequired[Any]
+    account_scope: NotRequired[Literal['operator', 'brand', 'operator_brand', 'agent']]
+    setup: NotRequired[_SyncAccountsResponseAccountsItemSetup]
+    rate_card: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay']]
+    credit_limit: NotRequired[_SyncAccountsResponseAccountsItemCreditLimit]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    sandbox: NotRequired[builtins.bool]
+    notification_configs: NotRequired[builtins.list[_ExternalCoreNotificationConfig]]
+    authorization: NotRequired[_ExternalCoreAccountAuthorization]
+
+class _SyncAgentNotificationConfigsRequestNotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['capabilities.changed']]]
+    authentication: NotRequired[_SyncAgentNotificationConfigsRequestNotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAgentNotificationConfig(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['capabilities.changed']]]
+    authentication: NotRequired[_ExternalCoreAgentNotificationConfigAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAudiencesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAudiencesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAudiencesRequestAudiencesItem(TypedDict, total=False):
+    audience_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    audience_type: NotRequired[Literal['crm', 'suppression', 'lookalike_seed']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    add: NotRequired[builtins.list[_ExternalCoreAudienceMember]]
+    remove: NotRequired[builtins.list[_ExternalCoreAudienceMember]]
+    delete: NotRequired[builtins.bool]
+    consent_basis: NotRequired[Literal['consent', 'legitimate_interest', 'contract', 'legal_obligation']]
+
+class _SyncAudiencesResponseAudiencesItem(TypedDict, total=False):
+    audience_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    seller_id: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'deleted', 'failed']]
+    status: NotRequired[Literal['processing', 'ready', 'too_small', 'suspended']]
+    uploaded_count: NotRequired[builtins.int]
+    total_uploaded_count: NotRequired[builtins.int]
+    matched_count: NotRequired[builtins.int]
+    effective_match_rate: NotRequired[builtins.float]
+    match_breakdown: NotRequired[builtins.list[_SyncAudiencesResponseAudiencesItemMatchBreakdownItem]]
+    last_synced_at: NotRequired[builtins.str]
+    minimum_size: NotRequired[builtins.int]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncCatalogsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncCatalogsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreCatalogItemAvailabilityUpdate(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    catalog_generation: Required[builtins.str]
+    item_id: Required[builtins.str]
+    expected_overlay_revision: Required[builtins.int]
+    action: Required[Literal['suppress', 'restore']]
+    reason: Required[Literal['out_of_stock', 'back_in_stock', 'content_unavailable', 'content_available', 'promotion_start', 'promotion_end', 'time_window_started', 'time_window_expired', 'buyer_request', 'other']]
+    reason_detail: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCatalogItemAvailabilityRef(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    catalog_generation: Required[builtins.str]
+    item_id: Required[builtins.str]
+
+class _SyncCatalogsResponseCatalogsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    catalog_generation: NotRequired[builtins.str]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    platform_id: NotRequired[builtins.str]
+    item_count: NotRequired[builtins.int]
+    items_approved: NotRequired[builtins.int]
+    items_pending: NotRequired[builtins.int]
+    items_rejected: NotRequired[builtins.int]
+    item_issues: NotRequired[builtins.list[_SyncCatalogsResponseCatalogsItemItemIssuesItem]]
+    last_synced_at: NotRequired[builtins.str]
+    next_fetch_at: NotRequired[builtins.str]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreCatalogItemAvailabilityUpdateResult(TypedDict, total=False):
+    request_index: Required[builtins.int]
+    catalog_id: Required[builtins.str]
+    catalog_generation: Required[builtins.str]
+    item_id: Required[builtins.str]
+    action: Required[Literal['suppress', 'restore']]
+    status: Required[Literal['applied', 'unchanged', 'failed']]
+    availability: NotRequired[Literal['active', 'suppressed']]
+    overlay_revision: NotRequired[builtins.int]
+    expires_at: NotRequired[builtins.str]
+    applied_at: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_ExternalCoreCatalogItemAvailabilityError]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCatalogItemAvailabilityState(TypedDict, total=False):
+    request_index: Required[builtins.int]
+    catalog_id: Required[builtins.str]
+    catalog_generation: Required[builtins.str]
+    item_id: Required[builtins.str]
+    status: Required[Literal['found', 'failed']]
+    availability: NotRequired[Literal['active', 'suppressed']]
+    overlay_revision: NotRequired[builtins.int]
+    expires_at: NotRequired[builtins.str]
+    updated_at: NotRequired[builtins.str]
+    errors: NotRequired[builtins.list[_ExternalCoreCatalogItemAvailabilityError]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncCatalogsResponseErrorsItem(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_SyncCatalogsResponseErrorsItemIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _SyncCreativesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncCreativesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncCreativesRequestCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant1 | _SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_SyncCreativesRequestCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    localization: NotRequired[_ExternalCoreCreativeLocalization | None]
+
+class _SyncCreativesRequestCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant1 | _SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_SyncCreativesRequestCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    localization: NotRequired[_ExternalCoreCreativeLocalization | None]
+
+class _SyncCreativesRequestAssignmentsItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesRequestAssignmentOperationsItemVariant1(TypedDict, total=False):
+    operation: Required[Literal['assign']]
+    creative_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesRequestAssignmentOperationsItemVariant2(TypedDict, total=False):
+    operation: Required[Literal['unassign']]
+    creative_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+
+class _SyncCreativesRequestAssignmentOperationsItemVariant3(TypedDict, total=False):
+    operation: Required[Literal['replace']]
+    creative_id: Required[builtins.str]
+    replaces_creative_id: Required[builtins.str]
+    package_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+
+class _SyncCreativesResponseCreativesItem(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    account: NotRequired[_ExternalCoreAccount]
+    action: Required[Literal['created', 'updated', 'unchanged', 'failed', 'deleted']]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    platform_id: NotRequired[builtins.str]
+    localization: NotRequired[_ExternalCoreCreativeLocalizationReadback]
+    changes: NotRequired[builtins.list[builtins.str]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    warnings: NotRequired[builtins.list[builtins.str]]
+    preview_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    assigned_to: NotRequired[builtins.list[builtins.str]]
+    assignment_errors: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncEventSourcesRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncEventSourcesRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncEventSourcesRequestEventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    value_currencies: NotRequired[builtins.list[builtins.str]]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    allowed_domains: NotRequired[builtins.list[builtins.str]]
+    surface: NotRequired[_ExternalCoreEventSurface]
+
+class _SyncEventSourcesResponseEventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+    seller_id: NotRequired[builtins.str]
+    event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    value_currencies: NotRequired[builtins.list[builtins.str]]
+    action_source: NotRequired[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    surface: NotRequired[_ExternalCoreEventSurface]
+    managed_by: NotRequired[Literal['buyer', 'seller']]
+    setup: NotRequired[_SyncEventSourcesResponseEventSourcesItemSetup]
+    action: Required[Literal['created', 'updated', 'unchanged', 'deleted', 'failed']]
+    health: NotRequired[_ExternalCoreEventSourceHealth]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncGovernanceRequestAccountsItem(TypedDict, total=False):
+    account: Required[_SyncGovernanceRequestAccountsItemAccountVariant1 | _SyncGovernanceRequestAccountsItemAccountVariant2]
+    governance_agents: Required[builtins.list[_SyncGovernanceRequestAccountsItemGovernanceAgentsItem]]
+
+class _SyncGovernanceResponseAccountsItem(TypedDict, total=False):
+    account: Required[_SyncGovernanceResponseAccountsItemAccountVariant1 | _SyncGovernanceResponseAccountsItemAccountVariant2]
+    status: Required[Literal['synced', 'failed']]
+    governance_agents: NotRequired[builtins.list[_SyncGovernanceResponseAccountsItemGovernanceAgentsItem]]
+    errors: NotRequired[builtins.list[_ExternalCoreError]]
+
+class _SyncPlansRequestPlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    brand: Required[_ExternalCoreBrandRef]
+    objectives: Required[builtins.str]
+    budget: Required[_SyncPlansRequestPlansItemBudgetVariant1 | _SyncPlansRequestPlansItemBudgetVariant2]
+    channels: NotRequired[_SyncPlansRequestPlansItemChannels]
+    flight: Required[_SyncPlansRequestPlansItemFlight]
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+    policy_ids: NotRequired[builtins.list[builtins.str]]
+    policy_categories: NotRequired[builtins.list[builtins.str]]
+    audience: NotRequired[_ExternalGovernanceAudienceConstraints]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    restricted_attributes_custom: NotRequired[builtins.list[builtins.str]]
+    min_audience_size: NotRequired[builtins.int]
+    human_review_required: NotRequired[builtins.bool]
+    custom_policies: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+    approved_sellers: NotRequired[builtins.list[builtins.str] | None]
+    delegations: NotRequired[builtins.list[_SyncPlansRequestPlansItemDelegationsItem]]
+    portfolio: NotRequired[_SyncPlansRequestPlansItemPortfolio]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncPlansResponsePlansItem(TypedDict, total=False):
+    plan_id: Required[builtins.str]
+    status: Required[Literal['active', 'error']]
+    version: Required[builtins.int]
+    categories: NotRequired[builtins.list[_SyncPlansResponsePlansItemCategoriesItem]]
+    resolved_policies: NotRequired[builtins.list[_SyncPlansResponsePlansItemResolvedPoliciesItem]]
+
+class _TasksGetRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_TasksGetRequestAccountVariant2Brand]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_TasksGetRequestAccountVariant2OperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _TasksGetResponseAdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksGetResponseAdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksGetResponsePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksGetResponsePushNotificationConfigAuthentication]
+
+class _TasksGetResponseProgress(TypedDict, total=False):
+    percentage: NotRequired[builtins.float]
+    current_step: NotRequired[builtins.str]
+    total_steps: NotRequired[builtins.int]
+    step_number: NotRequired[builtins.int]
+
+class _TasksGetResponseError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    details: NotRequired[_TasksGetResponseErrorDetails]
+
+class _TasksGetResponseHistoryItem(TypedDict, total=False):
+    timestamp: Required[builtins.str]
+    type: Required[Literal['request', 'response']]
+    data: Required[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _TasksListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_TasksListRequestAccountVariant2Brand]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_TasksListRequestAccountVariant2OperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _TasksListRequestFilters(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    protocols: NotRequired[builtins.list[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]]
+    status: NotRequired[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    statuses: NotRequired[builtins.list[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]]
+    task_type: NotRequired[Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']]
+    task_types: NotRequired[builtins.list[Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']]]
+    created_after: NotRequired[builtins.str]
+    created_before: NotRequired[builtins.str]
+    updated_after: NotRequired[builtins.str]
+    updated_before: NotRequired[builtins.str]
+    task_ids: NotRequired[builtins.list[builtins.str]]
+    context_contains: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _TasksListRequestSort(TypedDict, total=False):
+    field: NotRequired[Literal['created_at', 'updated_at', 'status', 'task_type', 'protocol']]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _TasksListRequestPagination(TypedDict, total=False):
+    max_results: NotRequired[builtins.int]
+    cursor: NotRequired[builtins.str]
+
+class _TasksListResponseAdcpError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_TasksListResponseAdcpErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _TasksListResponsePushNotificationConfig(TypedDict, total=False):
+    url: Required[builtins.str]
+    operation_id: NotRequired[builtins.str]
+    token: NotRequired[builtins.str]
+    authentication: NotRequired[_TasksListResponsePushNotificationConfigAuthentication]
+
+class _TasksListResponseQuerySummary(TypedDict, total=False):
+    total_matching: NotRequired[builtins.int]
+    returned: NotRequired[builtins.int]
+    domain_breakdown: NotRequired[_TasksListResponseQuerySummaryDomainBreakdown]
+    status_breakdown: NotRequired[builtins.dict[builtins.str, builtins.int]]
+    filters_applied: NotRequired[builtins.list[builtins.str]]
+    sort_applied: NotRequired[_TasksListResponseQuerySummarySortApplied]
+
+class _TasksListResponseTasksItem(TypedDict, total=False):
+    task_id: Required[builtins.str]
+    task_type: Required[Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']]
+    domain: Required[Literal['media-buy', 'signals', 'creative']]
+    status: Required[Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']]
+    created_at: Required[builtins.str]
+    updated_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str]
+    has_webhook: NotRequired[builtins.bool]
+
+class _TasksListResponsePagination(TypedDict, total=False):
+    has_more: Required[builtins.bool]
+    cursor: NotRequired[builtins.str]
+    total_count: NotRequired[builtins.int]
+
+class _UpdateCollectionListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateCollectionListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _UpdateContentStandardsRequestScope(TypedDict, total=False):
+    countries_all: NotRequired[builtins.list[builtins.str]]
+    channels_any: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    languages_any: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2]]
+
+class _UpdateMediaBuyRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateMediaBuyRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdateMediaBuyRequestTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalMediaBuyPackageUpdate(TypedDict, total=False):
+    package_id: Required[builtins.str]
+    budget: NotRequired[builtins.float | None]
+    min_spend_target: NotRequired[builtins.float | None]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bid_price: NotRequired[builtins.float]
+    bidding: NotRequired[_ExternalCoreBiddingPolicy | None]
+    impressions: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float | None]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[Literal[True]]
+    cancellation_reason: NotRequired[builtins.str]
+    catalogs: NotRequired[builtins.list[_ExternalCoreCatalog]]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3]]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    keyword_targets_add: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateKeywordTargetsAddItem]]
+    keyword_targets_remove: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateKeywordTargetsRemoveItem]]
+    negative_keywords_add: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateNegativeKeywordsAddItem]]
+    negative_keywords_remove: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateNegativeKeywordsRemoveItem]]
+    creative_assignments: NotRequired[builtins.list[_ExternalCoreCreativeAssignment]]
+    creatives: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateCreativesItemVariant1 | _ExternalMediaBuyPackageUpdateCreativesItemVariant2]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _UpdateMediaBuyResponseBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_UpdateMediaBuyResponseBiddingCostPer]
+    roas: NotRequired[_UpdateMediaBuyResponseBiddingRoas]
+
+class _UpdatePropertyListRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdatePropertyListRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _UpdatePropertyListRequestBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _UpdateRightsRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _UpdateRightsRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _UpdateRightsResponseRightsConstraint(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_UpdateRightsResponseRightsConstraintRightsAgent]
+    rights_holder: Required[_ExternalCoreBrandRef]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    grant_status: Required[Literal['active', 'paused', 'revoked']]
+    restrictions: NotRequired[builtins.list[builtins.str]]
+    disclosure: NotRequired[_UpdateRightsResponseRightsConstraintDisclosure]
+    creative_approval_required: NotRequired[builtins.bool]
+    verification_url: NotRequired[builtins.str]
+    content_digest: Required[builtins.str]
+    attestation_refs: Required[builtins.list[_UpdateRightsResponseRightsConstraintAttestationRefsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidateContentDeliveryRequestRecordsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    timestamp: NotRequired[builtins.str]
+    artifact: Required[_ExternalContentStandardsArtifact]
+    country: NotRequired[builtins.str]
+    channel: NotRequired[builtins.str]
+    brand_context: NotRequired[_ValidateContentDeliveryRequestRecordsItemBrandContext]
+
+class _ValidateContentDeliveryResponseSummary(TypedDict, total=False):
+    total_records: Required[builtins.int]
+    passed_records: Required[builtins.int]
+    failed_records: Required[builtins.int]
+
+class _ValidateContentDeliveryResponseResultsItem(TypedDict, total=False):
+    record_id: Required[builtins.str]
+    verdict: Required[Literal['pass', 'fail']]
+    features: NotRequired[builtins.list[_ValidateContentDeliveryResponseResultsItemFeaturesItem]]
+
+class _ValidateInputRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ValidateInputRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ValidateInputRequestManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ValidateInputRequestManifestVariant1FormatOptionRefVariant1 | _ValidateInputRequestManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidateInputRequestManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ValidateInputRequestManifestVariant2FormatOptionRefVariant1 | _ValidateInputRequestManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidateInputRequestTargetsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['canonical']]
+    id: Required[builtins.str]
+
+class _ValidateInputRequestTargetsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['product']]
+    id: Required[builtins.str]
+
+class _ValidateInputRequestTargetsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['third_party_format']]
+    id: Required[builtins.str]
+
+class _ValidateInputRequestTargetsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['capability']]
+    id: Required[builtins.str]
+
+class _ExternalCreativeValidateInputResult(TypedDict, total=False):
+    target: Required[_ExternalCreativeValidateInputResultTarget]
+    result_kind: Required[Literal['validated_pass', 'validated_fail', 'unvalidatable_nondeterministic']]
+    violations: NotRequired[builtins.list[_ExternalCreativeValidateInputResultViolationsItem]]
+
+class _ValidatePropertyDeliveryRequestAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ValidatePropertyDeliveryRequestAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalPropertyDeliveryRecord(TypedDict, total=False):
+    identifier: Required[_ExternalCoreIdentifier]
+    impressions: Required[builtins.int]
+    record_id: NotRequired[builtins.str]
+    sales_agent_url: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidatePropertyDeliveryResponseSummary(TypedDict, total=False):
+    total_records: Required[builtins.int]
+    total_impressions: Required[builtins.int]
+    compliant_records: Required[builtins.int]
+    compliant_impressions: Required[builtins.int]
+    non_compliant_records: Required[builtins.int]
+    non_compliant_impressions: Required[builtins.int]
+    not_covered_records: Required[builtins.int]
+    not_covered_impressions: Required[builtins.int]
+    unidentified_records: Required[builtins.int]
+    unidentified_impressions: Required[builtins.int]
+
+class _ValidatePropertyDeliveryResponseAggregate(TypedDict, total=False):
+    score: NotRequired[builtins.float]
+    grade: NotRequired[builtins.str]
+    label: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _ValidatePropertyDeliveryResponseAuthorizationSummary(TypedDict, total=False):
+    records_checked: Required[builtins.int]
+    impressions_checked: Required[builtins.int]
+    authorized_records: Required[builtins.int]
+    authorized_impressions: Required[builtins.int]
+    unauthorized_records: Required[builtins.int]
+    unauthorized_impressions: Required[builtins.int]
+    unknown_records: Required[builtins.int]
+    unknown_impressions: Required[builtins.int]
+
+class _ExternalPropertyValidationResult(TypedDict, total=False):
+    identifier: Required[_ExternalCoreIdentifier]
+    record_id: NotRequired[builtins.str]
+    status: Required[Literal['compliant', 'non_compliant', 'not_covered', 'unidentified']]
+    impressions: Required[builtins.int]
+    features: NotRequired[builtins.list[_ExternalPropertyValidationResultFeaturesItem]]
+    authorization: NotRequired[_ExternalPropertyAuthorizationResult]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _VerifyBrandClaimRequestClaim(TypedDict, total=False):
+    subsidiary_domain: Required[builtins.str]
+    subsidiary_brand_id: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimRequestClaim2(TypedDict, total=False):
+    parent_domain: Required[builtins.str]
+    claimant_says: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimRequestClaim3(TypedDict, total=False):
+    property: Required[_VerifyBrandClaimRequestClaim3Property]
+    use_case: NotRequired[builtins.str]
+
+class _VerifyBrandClaimRequestClaim4(TypedDict, total=False):
+    mark: Required[builtins.str]
+    registry: NotRequired[builtins.str]
+    number: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    use_case: NotRequired[builtins.str]
+
+class _SignedResponse(TypedDict, total=False):
+    protected: Required[builtins.str]
+    payload: Required[_SignedResponsePayload]
+    signature: Required[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant1(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant1Claim]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant2(TypedDict, total=False):
+    claim_type: Required[Literal['parent']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant2Claim]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant3(TypedDict, total=False):
+    claim_type: Required[Literal['property']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant3Claim]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant4(TypedDict, total=False):
+    claim_type: Required[Literal['trademark']]
+    claim: Required[_VerifyBrandClaimsRequestClaimsItemVariant4Claim]
+
+class _VerifyBrandClaimsResponseResultsItemVariant1(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary', 'parent', 'property', 'trademark']]
+    status: Required[Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown']]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    context_note: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsResponseResultsItemVariant2(TypedDict, total=False):
+    error: Required[_ExternalCoreError]
+
+class _SignedResponse2(TypedDict, total=False):
+    protected: Required[builtins.str]
+    payload: Required[_SignedResponse2Payload]
+    signature: Required[builtins.str]
+
+class _ExternalCoreErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_ExternalCoreErrorIssuesItemDiscriminatorItem]]
+
+class _ExternalCorePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalCoreReportingWebhookAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalMediaBuyCommercialTerms(TypedDict, total=False):
+    source_feed_version: NotRequired[builtins.str]
+    source_pricing_version: NotRequired[builtins.str]
+    brand: Required[_ExternalCoreBrandKey]
+    advertiser_industry: NotRequired[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']]
+    purchases: Required[builtins.list[_ExternalMediaBuyCommercialTermsPurchasesItem]]
+    start_time: Required[Literal['asap'] | builtins.str]
+    end_time: Required[builtins.str]
+    total_budget: NotRequired[_ExternalMediaBuyCommercialTermsTotalBudget]
+    daily_budget_cap: NotRequired[builtins.float]
+    budget_cap_timezone: NotRequired[builtins.str]
+    budget_allocation: NotRequired[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant1 | _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bidding: NotRequired[_ExternalCoreBiddingPolicy]
+    invoice_recipient: NotRequired[_ExternalCoreBusinessEntity]
+    purchase_order_ref: NotRequired[builtins.str]
+    agency_estimate_number: NotRequired[builtins.str]
+    reporting_commitments: NotRequired[builtins.list[_ExternalMediaBuyCommercialTermsReportingCommitmentsItem]]
+    cancellation_terms: NotRequired[_ExternalMediaBuyCommercialTermsCancellationTerms]
+
+class _ExternalCoreInsertionOrder(TypedDict, total=False):
+    io_id: Required[builtins.str]
+    terms: NotRequired[_ExternalCoreInsertionOrderTerms]
+    terms_url: NotRequired[builtins.str]
+    signing_url: NotRequired[builtins.str]
+    requires_signature: Required[builtins.bool]
+
+class _ExternalCoreSlaWindow(TypedDict, total=False):
+    response_max: NotRequired[builtins.str]
+    completion_max: NotRequired[builtins.str]
+
+class _ExternalCoreWarningResource(TypedDict, total=False):
+    resource_type: Required[Literal['media_buy', 'package', 'creative', 'creative_assignment']]
+    media_buy_id: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    creative_id: NotRequired[builtins.str]
+
+class _ExternalCoreBrandRefDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreBrandRefBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_ExternalCoreAssetsImageAsset]
+    colors: NotRequired[_ExternalCoreBrandRefBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _ExternalCoreOperatorUnit(TypedDict, total=False):
+    id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+
+class _AcquireRightsRequestCampaignFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _AcquireRightsRequestCampaignFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalBrandRightsTermsExclusivity(TypedDict, total=False):
+    scope: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _AcquireRightsResponseRightsConstraintRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _AcquireRightsResponseRightsConstraintDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    text: NotRequired[builtins.str]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItem(TypedDict, total=False):
+    issuer: Required[_AcquireRightsResponseRightsConstraintAttestationRefsItemIssuerVariant1 | _AcquireRightsResponseRightsConstraintAttestationRefsItemIssuerVariant2 | _AcquireRightsResponseRightsConstraintAttestationRefsItemIssuerVariant3]
+    claim_type: Required[Literal['https://adcontextprotocol.org/claims/rights/grant']]
+    subject: Required[_AcquireRightsResponseRightsConstraintAttestationRefsItemSubjectVariant1 | _AcquireRightsResponseRightsConstraintAttestationRefsItemSubjectVariant2 | _AcquireRightsResponseRightsConstraintAttestationRefsItemSubjectVariant3]
+    locator: NotRequired[_AcquireRightsResponseRightsConstraintAttestationRefsItemLocatorVariant1 | _AcquireRightsResponseRightsConstraintAttestationRefsItemLocatorVariant2]
+    embedded_credential: NotRequired[_AcquireRightsResponseRightsConstraintAttestationRefsItemEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_AcquireRightsResponseRightsConstraintAttestationRefsItemValidityHint]
+    verify_agent: NotRequired[_AcquireRightsResponseRightsConstraintAttestationRefsItemVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ActivateSignalResponseDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreRightsConstraint(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    rights_agent: Required[_ExternalCoreRightsConstraintRightsAgent]
+    rights_holder: NotRequired[_ExternalCoreBrandRef]
+    valid_from: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+    impression_cap: NotRequired[builtins.int]
+    right_type: NotRequired[Literal['talent', 'character', 'brand_ip', 'music', 'stock_media']]
+    approval_status: NotRequired[Literal['pending', 'approved', 'rejected']]
+    grant_status: NotRequired[Literal['active', 'paused', 'revoked']]
+    restrictions: NotRequired[builtins.list[builtins.str]]
+    disclosure: NotRequired[_ExternalCoreRightsConstraintDisclosure]
+    creative_approval_required: NotRequired[builtins.bool]
+    verification_url: NotRequired[builtins.str]
+    content_digest: NotRequired[builtins.str]
+    attestation_refs: NotRequired[builtins.list[_ExternalCoreRightsConstraintAttestationRefsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreIndustryIdentifier(TypedDict, total=False):
+    type: Required[Literal['ad_id', 'isci', 'clearcast_clock', 'idcrea']]
+    value: Required[builtins.str]
+
+class _ExternalCoreProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    synthetic_depiction: NotRequired[builtins.bool]
+    ai_tool: NotRequired[_ExternalCoreProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_ExternalCoreProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_ExternalCoreProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_ExternalCoreProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_ExternalCoreProvenanceWatermarksItem]]
+    disclosure: NotRequired[_ExternalCoreProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_ExternalCoreProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeRequestSignalConditionsItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreFeatureRequirement(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    allowed_values: NotRequired[builtins.list[Any]]
+    if_not_covered: NotRequired[Literal['exclude', 'include']]
+    policy_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant1RankByItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    direction: NotRequired[Literal['maximize', 'minimize']]
+
+class _BuildCreativeRequestEvaluatorVariant1FeatureAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant1EvalBudget(TypedDict, total=False):
+    max_calls: NotRequired[builtins.int]
+    max_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeRequestEvaluatorVariant1Exemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _BuildCreativeRequestEvaluatorVariant2RankByItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    direction: NotRequired[Literal['maximize', 'minimize']]
+
+class _BuildCreativeRequestEvaluatorVariant2FeatureAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant2EvalBudget(TypedDict, total=False):
+    max_calls: NotRequired[builtins.int]
+    max_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeRequestEvaluatorVariant3RankByItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    direction: NotRequired[Literal['maximize', 'minimize']]
+
+class _BuildCreativeRequestEvaluatorVariant3FeatureAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _BuildCreativeRequestEvaluatorVariant3EvalBudget(TypedDict, total=False):
+    max_calls: NotRequired[builtins.int]
+    max_seconds: NotRequired[builtins.float]
+
+class _BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponsePreviewPreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1 | _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2 | _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3]]
+    input: Required[_BuildCreativeResponsePreviewPreviewsItemInput]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativeManifestsItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponsePreview2PreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    capability_id: NotRequired[builtins.str]
+    renders: Required[builtins.list[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1 | _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2 | _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3]]
+    input: Required[_BuildCreativeResponsePreview2PreviewsItemInput]
+
+class _BuildCreativeResponseCreativesItemCatalogItemRef(TypedDict, total=False):
+    catalog_type: NotRequired[builtins.str]
+    item_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant2 | _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant3]
+    signal_id: NotRequired[_BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant1 | _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _BuildCreativeResponseCreativesItemVariantsItem(TypedDict, total=False):
+    build_variant_id: Required[builtins.str]
+    recipe_hash: NotRequired[builtins.str]
+    parent_build_variant_id: NotRequired[builtins.str]
+    creative_manifest: Required[_BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1 | _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2]
+    variant_axis_value: NotRequired[Any]
+    recommended: NotRequired[builtins.bool]
+    rank: NotRequired[builtins.int]
+    eval: NotRequired[_BuildCreativeResponseCreativesItemVariantsItemEval]
+    pricing_option_id: NotRequired[builtins.str]
+    vendor_cost: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    consumption: NotRequired[_ExternalCoreCreativeConsumption]
+
+class _BuildCreativeResponseEstimatePerLeafItem(TypedDict, total=False):
+    catalog_item_ref: NotRequired[builtins.dict[builtins.str, Any]]
+    variant_axis_value: NotRequired[Any]
+    pricing_option_id: NotRequired[builtins.str]
+    cost_low: NotRequired[builtins.float]
+    cost_high: NotRequired[builtins.float]
+    consumption_estimate: NotRequired[_ExternalCoreCreativeConsumption]
+
+class _ExternalCoreCanonicalPricingOption(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'revenue_share', 'flat_rate', 'time']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+    parameters: NotRequired[builtins.dict[builtins.str, Any]]
+    event_type: NotRequired[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: NotRequired[builtins.str]
+    commission_rate: NotRequired[builtins.float]
+    commission_basis_description: NotRequired[builtins.str]
+
+class _ExternalMediaBuyProductPurchaseFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyProductPurchaseFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant1Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant2Target]
+    attribution_window: NotRequired[_ExternalCoreAttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant3Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreProductAudienceEvidenceRequirements(TypedDict, total=False):
+    requirement_mode: Required[Literal['required', 'preferred']]
+    evidence_presence: Required[Literal['required', 'when_available']]
+    accepted_methodologies: NotRequired[builtins.list[Literal['observed', 'declared', 'derived', 'inferred', 'modeled', 'projected']]]
+    excluded_methodologies: NotRequired[builtins.list[Literal['observed', 'declared', 'derived', 'inferred', 'modeled', 'projected']]]
+    accepted_evidence_types: NotRequired[builtins.list[Literal['measured', 'forecast', 'seller_declared']]]
+    accepted_providers: NotRequired[builtins.list[_ExternalCoreBrandKey]]
+    excluded_providers: NotRequired[builtins.list[_ExternalCoreBrandKey]]
+    accepted_subject_types: NotRequired[builtins.list[Literal['individual', 'household', 'business', 'contextual', 'none']]]
+    accepted_resolution_methods: NotRequired[builtins.list[Literal['deterministic_id', 'probabilistic_device', 'browser', 'geographic', 'content_signal', 'mixed']]]
+    minimum_confidence: NotRequired[builtins.float]
+    maximum_age: NotRequired[_ExternalCoreProductAudienceEvidenceRequirementsMaximumAge]
+    methodology_documentation_required: NotRequired[builtins.bool]
+    independent_attestation_required: NotRequired[builtins.bool]
+    accepted_attestation_issuers: NotRequired[builtins.list[_ExternalCoreProductAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant1 | _ExternalCoreProductAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant2 | _ExternalCoreProductAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant3]]
+    accepted_attestation_claim_types: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalMeasurementTerms(TypedDict, total=False):
+    billing_measurement: NotRequired[_ExternalCoreCanonicalMeasurementTermsBillingMeasurement]
+    makegood_policy: NotRequired[_ExternalCoreCanonicalMeasurementTermsMakegoodPolicy]
+
+class _ExternalCoreCanonicalPerformanceStandard(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_ExternalCoreBrandKey]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1Target]
+    priority: NotRequired[builtins.int]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2Target]
+    attribution_window: NotRequired[_ExternalCoreAttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreBiddingPolicyCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _ExternalCoreBiddingPolicyRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _ExternalCoreBusinessEntityAddress(TypedDict, total=False):
+    street: Required[builtins.str]
+    city: Required[builtins.str]
+    postal_code: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    country: Required[builtins.str]
+
+class _ExternalCoreBusinessEntityContactsItem(TypedDict, total=False):
+    role: Required[Literal['billing', 'legal', 'creative', 'general']]
+    name: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+
+class _ExternalCoreBusinessEntityBank(TypedDict, total=False):
+    account_holder: Required[builtins.str]
+    iban: NotRequired[builtins.str]
+    bic: NotRequired[builtins.str]
+    routing_number: NotRequired[builtins.str]
+    account_number: NotRequired[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant1 | _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant2 | _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalContentStandardsArtifactMetadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _ExternalContentStandardsArtifactIdentifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _ExternalCorePlannedDeliveryGeo(TypedDict, total=False):
+    countries: NotRequired[builtins.list[builtins.str]]
+    regions: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreFrequencyCap(TypedDict, total=False):
+    suppress: NotRequired[_ExternalCoreFrequencyCapSuppress]
+    suppress_minutes: NotRequired[builtins.float]
+    max_impressions: NotRequired[builtins.int]
+    per: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    window: NotRequired[_ExternalCoreFrequencyCapWindow]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant2 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1 | _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalCorePlannedDeliveryBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_ExternalCorePlannedDeliveryBiddingCostPer]
+    roas: NotRequired[_ExternalCorePlannedDeliveryBiddingRoas]
+
+class _CheckGovernanceRequestDeliveryMetricsReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _CheckGovernanceRequestDeliveryMetricsAudienceDistribution(TypedDict, total=False):
+    baseline: Required[Literal['census', 'platform', 'custom']]
+    baseline_description: NotRequired[builtins.str]
+    indices: Required[builtins.dict[builtins.str, builtins.float]]
+    cumulative_indices: NotRequired[builtins.dict[builtins.str, builtins.float]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemIssuerVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemIssuerVariant3(TypedDict, total=False):
+    type: Required[Literal['origin']]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemSubjectVariant1(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/signal']]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemSubjectVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/signal']]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemSubjectVariant3(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/signal']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _CheckGovernanceRequestRuntimeAttestationsItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _CheckGovernanceResponseDeliveryStatementReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _CheckGovernanceResponseDeliveryStatementCanonicalPayload(TypedDict, total=False):
+    seller_reference: Required[builtins.str]
+    delivery_metrics: Required[builtins.dict[builtins.str, Any]]
+
+class _CheckGovernanceResponseRuntimeAttestationEvaluationsItemActionBinding(TypedDict, total=False):
+    action_type: Required[Literal['https://adcontextprotocol.org/actions/governance-check']]
+
+class _ComplyTestControllerRequestParamsReportedSpend(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ComplyTestControllerRequestParamsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ComplyTestControllerRequestParamsReachWindowPeriod]
+
+class _ComplyTestControllerRequestParamsViewability(TypedDict, total=False):
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreVendorMetricValue(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    value: Required[builtins.float]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[builtins.float]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ComplyTestControllerRequestParamsNotYetMeasurableVendorMetricsItem(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ComplyTestControllerRequestParamsNotYetMeasurableVendorMetricsByPackageValueItem(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ComplyTestControllerRequestParamsMetricsItem(TypedDict, total=False):
+    metric_id: Required[builtins.str]
+
+class _ExternalCreativeAuditObservationDetails(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+    claimed_value: Required[_ExternalCreativeAuditObservationDetailsClaimedValue]
+    observed_value: NotRequired[builtins.bool | builtins.float | builtins.str | None]
+    confidence: NotRequired[builtins.float]
+    substituted_for: NotRequired[builtins.str]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant1IdentifierMatchProofsItem(TypedDict, total=False):
+    identifier_value_sha256: Required[builtins.str]
+    found: Required[builtins.bool]
+
+class _ComplyTestControllerResponseRecordedCallsItemVariant2IdentifierMatchProofsItem(TypedDict, total=False):
+    identifier_value_sha256: Required[builtins.str]
+    found: Required[builtins.bool]
+
+class _ContextMatchRequestGeoMetro(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    value: Required[builtins.str]
+
+class _ExternalCoreSellerAgentRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    id: NotRequired[builtins.str]
+
+class _ExternalTrustedMatchOfferPrice(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: NotRequired[builtins.str]
+    model: Required[Literal['cpm', 'cpc', 'cpcv', 'cpa', 'flat']]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant1 | _ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant1 | _ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TargetingKvsItem(TypedDict, total=False):
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1Target]
+    priority: NotRequired[builtins.int]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2Target]
+    attribution_window: NotRequired[_ExternalCoreAttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreKeywordTarget(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageControlOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageControlOptimizationGoalsItemVariant1Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageControlOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageControlOptimizationGoalsItemVariant2Target]
+    attribution_window: NotRequired[_ExternalCoreAttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyPackageControlOptimizationGoalsItemVariant3Target]
+    priority: NotRequired[builtins.int]
+
+class _CreateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _ExternalCoreContentRating(TypedDict, total=False):
+    system: Required[Literal['tv_parental', 'mpaa', 'podcast', 'esrb', 'bbfc', 'fsk', 'acb', 'chvrs', 'csa', 'pegi', 'custom']]
+    rating: Required[builtins.str]
+
+class _ExternalCollectionCollectionListFiltersExcludeDistributionIdsItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _ExternalCollectionCollectionListAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalCollectionCollectionListAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['distribution_ids']]
+    identifiers: Required[builtins.list[_ExternalCollectionCollectionListBaseCollectionsItemVariant1IdentifiersItem]]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_collections']]
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_genres']]
+    publisher_domain: Required[builtins.str]
+    genres: Required[builtins.list[builtins.str]]
+    genre_taxonomy: Required[Literal['iab_content_3.0', 'iab_content_2.2', 'gracenote', 'eidr', 'apple_genres', 'google_genres', 'roku', 'amazon_genres', 'custom']]
+
+class _ExternalGovernancePolicyEntryExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_Exemplar]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant1(TypedDict, total=False):
+    type: Required[Literal['url']]
+    value: Required[builtins.str]
+    language: NotRequired[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4]]
+    metadata: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageRequestBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_ExternalMediaBuyPackageRequestBiddingCostPer]
+    roas: NotRequired[_ExternalMediaBuyPackageRequestBiddingRoas]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant2 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant1 | _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1Qualifier]
+
+class _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant1 | _ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant1 | _ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageRequestCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+
+class _CreateMediaBuyRequestBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _CreateMediaBuyRequestBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _CreateMediaBuyRequestArtifactWebhookAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalCoreAccountIdentityChangeVariant1(TypedDict, total=False):
+    status: Required[Literal['pending_approval']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    requested_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountIdentityChangeVariant2(TypedDict, total=False):
+    status: Required[Literal['rejected']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    requested_at: NotRequired[builtins.str]
+    reason: Required[builtins.str]
+
+class _ExternalCoreAccountCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAccountSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _ExternalCoreAccountReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _ExternalCoreNotificationConfig(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['creative.status_changed', 'creative.assignment_changed', 'indicators.changed', 'creative.purged', 'account.status_changed', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    product_payload_view: NotRequired[Literal['canonical', 'legacy']]
+    authentication: NotRequired[_ExternalCoreNotificationConfigAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreWebhookActivityRecord(TypedDict, total=False):
+    idempotency_key: Required[builtins.str]
+    notification_id: NotRequired[builtins.str]
+    subscriber_id: NotRequired[builtins.str]
+    fired_at: Required[builtins.str]
+    completed_at: NotRequired[builtins.str | None]
+    notification_type: Required[Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update', 'impairment', 'creative.status_changed', 'creative.assignment_changed', 'indicators.changed', 'creative.purged', 'account.status_changed', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change', 'capabilities.changed']]
+    sequence_number: NotRequired[builtins.int]
+    attempt: Required[builtins.int]
+    status: Required[Literal['success', 'failed', 'timeout', 'connection_error', 'pending']]
+    url: Required[builtins.str]
+    http_status_code: NotRequired[builtins.int | None]
+    response_time_ms: NotRequired[builtins.int | None]
+    payload_size_bytes: NotRequired[builtins.int]
+    error_message: NotRequired[builtins.str | None]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _CreateMediaBuyResponseBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _CreateMediaBuyResponseBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _ExternalCoreAudienceEvidenceSelection(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    snapshot_id: Required[builtins.str]
+    version: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    decision_use: Required[Literal['recommendation', 'eligibility', 'package_construction']]
+    evidence: NotRequired[_ExternalCoreAudienceEvidence]
+    attestation_evaluations: NotRequired[builtins.list[_ExternalCoreAudienceEvidenceSelectionAttestationEvaluationsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_ExternalCorePackageBiddingCostPer]
+    roas: NotRequired[_ExternalCorePackageBiddingRoas]
+
+class _ExternalPricingOptionsPriceBreakdown(TypedDict, total=False):
+    list_price: Required[builtins.float]
+    adjustments: Required[builtins.list[_ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant1 | _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant2]]
+
+class _ExternalCorePackageFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCorePackageFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCorePackageTargetingResolution(TypedDict, total=False):
+    demographics: Required[_ExternalCoreDemographicTargetingResolution]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageCommittedMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_ExternalCorePackageCommittedMetricsItemVariant1Qualifier]
+    committed_at: Required[builtins.str]
+
+class _ExternalCorePackageCommittedMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    committed_at: Required[builtins.str]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant1 | _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant2 | _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant3 | _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant4]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant1 | _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant2 | _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant3 | _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant4]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant1 | _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant2 | _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant3 | _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant4]
+
+class _ExternalCorePackageFormatsToProvideItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCorePackageFormatsToProvideItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCorePackageFormatsToProvideItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCorePackageFormatsToProvideItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCorePackageFormatsToProvideItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCorePackageFormatsToProvideItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCorePackageFormatsToProvideItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCorePackageFormatsToProvideItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCorePackageFormatsToProvideItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCorePackageFormatsToProvideItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageFormatsPendingItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant1 | _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant2 | _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant3 | _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant4]
+
+class _ExternalCorePackageFormatsPendingItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant1 | _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant2 | _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant3 | _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant4]
+
+class _ExternalCorePackageFormatsPendingItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant1 | _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant2 | _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant3 | _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant4]
+
+class _ExternalCorePackageFormatsPendingItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCorePackageFormatsPendingItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCorePackageFormatsPendingItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCorePackageFormatsPendingItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCorePackageFormatsPendingItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCorePackageFormatsPendingItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCorePackageFormatsPendingItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCorePackageFormatsPendingItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCorePackageFormatsPendingItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCorePackageFormatsPendingItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalCorePackageOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant2 | _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant1 | _ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePackageCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+    acknowledged_at: NotRequired[builtins.str]
+
+class _ExternalPropertyPropertyListAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalPropertyPropertyListAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant1(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_tags']]
+    publisher_domain: Required[builtins.str]
+    tags: Required[builtins.list[builtins.str]]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant2(TypedDict, total=False):
+    selection_type: Required[Literal['publisher_ids']]
+    publisher_domain: Required[builtins.str]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalPropertyPropertyListBasePropertiesItemVariant3(TypedDict, total=False):
+    selection_type: Required[Literal['identifiers']]
+    identifiers: Required[builtins.list[_ExternalCoreIdentifier]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalPropertyPropertyListPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _DeclineProposalsRequestPushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _GetAccountFinancialsResponseBalanceLastTopUp(TypedDict, total=False):
+    amount: Required[builtins.float]
+    date: Required[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant1(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    replay_ttl_seconds: Required[builtins.int]
+    in_flight_max_seconds: NotRequired[builtins.int]
+    account_id_is_opaque: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseAdcpIdempotencyVariant2(TypedDict, total=False):
+    supported: Required[Literal[False]]
+
+class _GetAdcpCapabilitiesResponseAdcpCapabilityChanges(TypedDict, total=False):
+    capabilities_version: NotRequired[builtins.str]
+    last_modified: NotRequired[builtins.str]
+    cache_ttl_seconds: NotRequired[builtins.int]
+    notifications: NotRequired[_GetAdcpCapabilitiesResponseAdcpCapabilityChangesNotificationsVariant1 | _GetAdcpCapabilitiesResponseAdcpCapabilityChangesNotificationsVariant2]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcement(TypedDict, total=False):
+    tasks: Required[builtins.list[_GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant1 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant2 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant3 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant4 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant5 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant6 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant7 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant8 | _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant9]]
+
+class _ExternalCoreAttestationCapabilities(TypedDict, total=False):
+    accepted_claim_types: Required[builtins.list[builtins.str]]
+    accepted_proof_formats: Required[builtins.list[builtins.str]]
+    supported_delivery_methods: Required[builtins.list[Literal['credential_uri', 'issuer_credential_id', 'embedded']]]
+    accepted_issuers: Required[builtins.list[_ExternalCoreAttestationCapabilitiesAcceptedIssuersItem]]
+    accepted_verifiers: NotRequired[builtins.list[_ExternalCoreAttestationCapabilitiesAcceptedVerifiersItem]]
+    max_embedded_credential_bytes: NotRequired[builtins.int]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAccountTimezoneCapability(TypedDict, total=False):
+    mode: Required[Literal['seller_fixed', 'account_fixed']]
+    fixed_timezone: NotRequired[builtins.str]
+    account_selection: NotRequired[Literal['seller_assigned', 'buyer_selected']]
+    supported_timezones: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseAccountNotificationsVariant1(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    registration_task: Required[Literal['sync_accounts']]
+    read_task: Required[Literal['list_accounts']]
+    event_types: Required[builtins.list[Literal['account.status_changed']]]
+    supports_webhook_activity: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseAccountNotificationsVariant2(TypedDict, total=False):
+    supported: Required[Literal[False]]
+
+class _GetAdcpCapabilitiesResponseAccountIdentityUpdatesVariant1(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    supported_changes: Required[builtins.list[Literal['operator_unit_name', 'operator_unit', 'operator']]]
+
+class _GetAdcpCapabilitiesResponseAccountIdentityUpdatesVariant2(TypedDict, total=False):
+    supported: Required[Literal[False]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyProposalRefinement(TypedDict, total=False):
+    supported_dimensions: Required[builtins.list[Literal['total_budget', 'cpm', 'impressions', 'flight', 'product_changes', 'alternatives', 'criteria']]]
+    max_alternatives: NotRequired[builtins.int]
+
+class _GetAdcpCapabilitiesResponseMediaBuyPerformanceFeedback(TypedDict, total=False):
+    reports_application_status: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyRelationshipNotifications(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    registration_task: Required[Literal['sync_accounts']]
+    event_types: Required[builtins.list[Literal['indicators.changed', 'creative.assignment_changed']]]
+    repair_tasks: Required[builtins.list[Literal['get_media_buys']]]
+    projection_tasks: NotRequired[builtins.list[Literal['list_creatives']]]
+    supports_webhook_activity: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyFeatures(TypedDict, total=False):
+    inline_creative_management: NotRequired[builtins.bool]
+    property_list_filtering: NotRequired[builtins.bool]
+    catalog_management: NotRequired[builtins.bool]
+    catalog_item_availability_updates: NotRequired[builtins.bool]
+    committed_metrics_supported: NotRequired[builtins.bool]
+    seller_optimized_budget: NotRequired[builtins.bool]
+    bidding_policy: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyFeaturesBiddingPolicy]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecution(TypedDict, total=False):
+    trusted_match: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTrustedMatch]
+    axe_integrations: NotRequired[builtins.list[builtins.str]]
+    creative_specs: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionCreativeSpecs]
+    targeting: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargeting]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceEvidence(TypedDict, total=False):
+    supported_requirement_modes: Required[builtins.list[Literal['required', 'preferred']]]
+    supported_presence_modes: Required[builtins.list[Literal['required', 'when_available']]]
+    supports_attestation_evaluation: Required[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyRightsAttestations(TypedDict, total=False):
+    requirement: Required[Literal['optional', 'required']]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceTargeting(TypedDict, total=False):
+    supported_identifier_types: Required[builtins.list[Literal['hashed_email', 'hashed_phone']]]
+    supports_platform_customer_id: NotRequired[builtins.bool]
+    supported_uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+    minimum_audience_size: Required[builtins.int]
+    matching_latency_hours: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyAudienceTargetingMatchingLatencyHours]
+
+class _GetAdcpCapabilitiesResponseMediaBuyVendorMetricOptimization(TypedDict, total=False):
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyConversionTracking(TypedDict, total=False):
+    multi_source_event_dedup: NotRequired[builtins.bool]
+    per_creative_attribution: NotRequired[builtins.bool]
+    supported_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    supported_uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+    supported_hashed_identifiers: NotRequired[builtins.list[Literal['hashed_email', 'hashed_phone']]]
+    supported_action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    attribution_windows: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseMediaBuyConversionTrackingAttributionWindowsItem]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyFrequencyCapping(TypedDict, total=False):
+    supported_per_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_window_units: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyBudgetCapping(TypedDict, total=False):
+    supported_scopes: Required[builtins.list[Literal['media_buy', 'package']]]
+    supported_periods: Required[builtins.list[Literal['day']]]
+    timezone_basis: Required[Literal['account', 'fixed']]
+    fixed_timezone: NotRequired[builtins.str]
+    buyer_timezone_override: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyContentStandards(TypedDict, total=False):
+    supports_local_evaluation: NotRequired[builtins.bool]
+    supported_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    supports_webhook_delivery: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyPortfolio(TypedDict, total=False):
+    publisher_domains: Required[builtins.list[builtins.str]]
+    primary_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    primary_countries: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    advertising_policies: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseSignalsFeatures(TypedDict, total=False):
+    catalog_signals: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseGovernanceRuntimeAttestations(TypedDict, total=False):
+    signal_activation: Required[_GetAdcpCapabilitiesResponseGovernanceRuntimeAttestationsSignalActivation]
+
+class _GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    type: Required[Literal['binary', 'quantitative', 'categorical']]
+    range: NotRequired[_GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItemRange]
+    categories: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    type: Required[Literal['binary', 'quantitative', 'categorical']]
+    range: NotRequired[_GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItemRange]
+    categories: NotRequired[builtins.list[builtins.str]]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpoint(TypedDict, total=False):
+    transports: Required[builtins.list[_GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpointTransportsItem]]
+    preferred: NotRequired[Literal['mcp', 'a2a']]
+
+class _GetAdcpCapabilitiesResponseCreativeMultiplicity(TypedDict, total=False):
+    supports_catalog_fanout: NotRequired[builtins.bool]
+    max_creatives_limit: NotRequired[builtins.int]
+    supports_signal_fanout: NotRequired[builtins.bool]
+    max_signal_conditions_limit: NotRequired[builtins.int]
+    supports_variants: NotRequired[builtins.bool]
+    max_variants_limit: NotRequired[builtins.int]
+    variant_dimensions: NotRequired[builtins.list[Literal['voice', 'theme', 'best_of_n', 'transformer_config', 'custom']]]
+    selection_strategies: NotRequired[builtins.list[Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random']]]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItem(TypedDict, total=False):
+    capability_id: NotRequired[builtins.str]
+    format: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant4 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant5 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant6 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant7 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant8 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant9 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant10 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant11 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant12 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant13]
+    operations: NotRequired[builtins.list[Literal['build', 'validate', 'preview']]]
+
+class _GetAdcpCapabilitiesResponseCreativeLocalization(TypedDict, total=False):
+    max_target_variants: NotRequired[builtins.int]
+    locale_matching: Required[Literal['rfc4647_lookup']]
+
+class _GetAdcpCapabilitiesResponseIdentityKeyOrigins(TypedDict, total=False):
+    governance_signing: NotRequired[builtins.str]
+    request_signing: NotRequired[builtins.str]
+    webhook_signing: NotRequired[builtins.str]
+    tmp_signing: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseIdentityCompromiseNotification(TypedDict, total=False):
+    emits: NotRequired[builtins.bool]
+    accepts: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMeasurementMetricsItem(TypedDict, total=False):
+    metric_id: Required[builtins.str]
+    standard_reference: NotRequired[builtins.str]
+    accreditations: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseMeasurementMetricsItemAccreditationsItem]]
+    unit: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    methodology_version: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _FontRoleVariant2(TypedDict, total=False):
+    family: Required[builtins.str]
+    files: NotRequired[builtins.list[_FontRoleVariant2FilesItem]]
+    opentype_features: NotRequired[builtins.list[builtins.str]]
+    fallbacks: NotRequired[builtins.list[builtins.str]]
+
+class _GetCollectionListResponseCollectionsItemDistributionIdsItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _GetContentStandardsResponsePricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _GetCreativeDeliveryResponseCreativesItemFormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetCreativeDeliveryResponseCreativesItemFormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreDeliveryMetrics(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreDeliveryMetricsQuartileData | _ExternalCoreDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+
+class _ExternalCoreCreativeVariant(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCreativeVariantByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreCreativeVariantReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCreativeVariantQuartileData | _ExternalCoreCreativeVariantQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreCreativeVariantDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCreativeVariantViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCreativeVariantByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    variant_id: Required[builtins.str]
+    locale_variant_id: NotRequired[builtins.str]
+    manifest: NotRequired[_ExternalCoreCreativeVariantManifestVariant1 | _ExternalCoreCreativeVariantManifestVariant2]
+    generation_context: NotRequired[_ExternalCoreCreativeVariantGenerationContext]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetCreativeFeaturesRequestCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _GetMediaBuyArtifactsResponseArtifactsItemBrandContext(TypedDict, total=False):
+    brand_id: NotRequired[builtins.str]
+    sku_id: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryRequestAttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryRequestAttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsGeo(TypedDict, total=False):
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom', 'postal_code', 'zip', 'zip_plus_four', 'outward', 'full', 'fsa', 'plz', 'code_postal', 'postcode', 'cep', 'pin', 'us_zip', 'us_zip_plus_four', 'gb_outward', 'gb_full', 'ca_fsa', 'ca_full', 'de_plz', 'fr_code_postal', 'au_postcode', 'ch_plz', 'at_plz']]
+    country: NotRequired[builtins.str]
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDeviceType(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDevicePlatform(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsAudience(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsDemographic(TypedDict, total=False):
+    age_ranges: NotRequired[builtins.list[_ExternalCoreDemographicAgeRange]]
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsSpot(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryRequestReportingDimensionsPlacement(TypedDict, total=False):
+    limit: NotRequired[builtins.int]
+    sort_by: NotRequired[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'grps', 'reach', 'frequency', 'engagements', 'follows', 'saves', 'profile_visits', 'engagement_rate', 'cost_per_click']]
+
+class _ExternalCoreAttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreAttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1Qualifier]
+    value: Required[builtins.float]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    qualifier: NotRequired[builtins.dict[builtins.str, Any]]
+    value: Required[builtins.float]
+    measurable_impressions: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotals(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    effective_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    package_id: Required[builtins.str]
+    pacing_index: NotRequired[builtins.float]
+    pricing_model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'revenue_share', 'flat_rate', 'time']]
+    rate: Required[builtins.float]
+    currency: Required[builtins.str]
+    delivery_status: NotRequired[Literal['delivering', 'not_delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    paused: NotRequired[builtins.bool]
+    is_final: NotRequired[builtins.bool]
+    finalized_at: NotRequired[builtins.str]
+    measurement_window: NotRequired[builtins.str]
+    supersedes_window: NotRequired[builtins.str]
+    missing_metrics: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1 | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant2]]
+    by_catalog_item: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetrics]]
+    by_creative: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetrics]]
+    by_keyword: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetrics]]
+    by_geo: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetrics]]
+    by_geo_truncated: NotRequired[builtins.bool]
+    by_device_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItem]]
+    by_device_type_truncated: NotRequired[builtins.bool]
+    by_device_platform: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItem]]
+    by_device_platform_truncated: NotRequired[builtins.bool]
+    by_audience: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItem]]
+    by_audience_truncated: NotRequired[builtins.bool]
+    by_demographic: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItem]]
+    by_demographic_truncated: NotRequired[builtins.bool]
+    by_demographic_suppressed: NotRequired[builtins.bool]
+    by_placement: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItem]]
+    by_placement_truncated: NotRequired[builtins.bool]
+    by_spot: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItem]]
+    by_spot_truncated: NotRequired[builtins.bool]
+    daily_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDailyBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItem(TypedDict, total=False):
+    window_start: Required[builtins.str]
+    window_end: Required[builtins.str]
+    totals: Required[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotals]
+    by_package: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItem]]
+    is_final: NotRequired[builtins.bool]
+    measurement_window: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemDailyBreakdownItem(TypedDict, total=False):
+    date: Required[builtins.str]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+
+class _ExternalCoreIndicator(TypedDict, total=False):
+    type: Required[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]
+    detected_at: NotRequired[builtins.str]
+    scope: NotRequired[builtins.list[_ExternalCoreIndicatorScope]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreIndicatorScope(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    placement_id: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemAcceptedProposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: NotRequired[builtins.str]
+    media_buy_id: Required[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['accepted']]
+    accepted_at: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _ExternalCoreImpairment(TypedDict, total=False):
+    impairment_id: Required[builtins.str]
+    resource_type: Required[Literal['audience', 'creative', 'catalog_item', 'event_source', 'property']]
+    resource_id: Required[builtins.str]
+    package_ids: Required[builtins.list[builtins.str]]
+    transition: Required[_ExternalCoreImpairmentTransition]
+    reason_code: Required[Literal['policy_violation', 'consent_expired', 'ttl_expired', 'pii_audit_failed', 'seller_removed', 'content_rejected', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_offline', 'property_depublished']]
+    reason: NotRequired[builtins.str]
+    observed_at: Required[builtins.str]
+    remediation: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _GetMediaBuysResponseMediaBuysItemBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_GetMediaBuysResponseMediaBuysItemBiddingCostPer]
+    roas: NotRequired[_GetMediaBuysResponseMediaBuysItemBiddingRoas]
+
+class _GetMediaBuysResponseMediaBuysItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemAvailableActionsItemVariant1Variant1(TypedDict, total=False):
+    task: Required[Literal['control_media_buy']]
+    action: Required[Literal['pause', 'resume', 'cancel', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'update_catalog_assignments', 'update_keywords', 'update_optimization_goals', 'update_impression_goal', 'update_spend_target', 'update_reporting_webhook', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemAvailableActionsItemVariant1Variant2(TypedDict, total=False):
+    task: Required[Literal['refine_proposals']]
+    action: Required[Literal['cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'add_packages', 'remove_packages']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemAvailableActionsItemVariant1Variant3(TypedDict, total=False):
+    task: Required[Literal['sync_creatives']]
+    action: Required[Literal['replace_creative', 'update_creative_assignments', 'remove_creative']]
+    mode: Required[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemHistoryItem(TypedDict, total=False):
+    revision: Required[builtins.int]
+    timestamp: Required[builtins.str]
+    actor: NotRequired[builtins.str]
+    action: Required[builtins.str]
+    summary: NotRequired[builtins.str]
+    package_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItem(TypedDict, total=False):
+    indicators: NotRequired[builtins.list[_ExternalCoreIndicator]]
+    indicator_types_evaluated: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    indicators_as_of: NotRequired[builtins.str]
+    indicators_evaluated_scope: NotRequired[builtins.list[_ExternalCoreIndicatorScope]]
+    package_id: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    min_spend_target: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    bid_price: NotRequired[builtins.float]
+    bidding: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemBidding]
+    optimization_goals: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant3]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_option_refs: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant2]]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: NotRequired[builtins.dict[builtins.str, Any]]
+    impressions: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    targeting_resolution: NotRequired[_ExternalCorePackageTargetingResolution]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    paused: NotRequired[builtins.bool]
+    canceled: NotRequired[builtins.bool]
+    cancellation: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemCancellation]
+    creative_deadline: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    creative_approvals: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemCreativeApprovalsItem]]
+    formats_to_provide: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant4 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant5 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant6 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant7 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant8 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant9 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant10 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant11 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant12 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant13]]
+    formats_pending: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant4 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant5 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant6 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant7 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant8 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant9 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant10 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant11 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant12 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant13]]
+    format_ids_to_provide: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_ids_pending: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    snapshot_unavailable_reason: NotRequired[Literal['SNAPSHOT_UNSUPPORTED', 'SNAPSHOT_TEMPORARILY_UNAVAILABLE', 'SNAPSHOT_PERMISSION_DENIED']]
+    snapshot: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemSnapshot]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemBudget(TypedDict, total=False):
+    authorized: NotRequired[builtins.float]
+    accounting_mode: NotRequired[Literal['gross_commitment', 'verified_net_cost']]
+    committed: NotRequired[builtins.float]
+    gross_committed: NotRequired[builtins.float]
+    adjustments_reported: NotRequired[builtins.float]
+    adjustments_verified: NotRequired[builtins.float]
+    net_cost: NotRequired[builtins.float]
+    headroom_restored: NotRequired[builtins.float]
+    net_committed: NotRequired[builtins.float]
+    ledger_committed: NotRequired[builtins.float]
+    remaining: NotRequired[builtins.float]
+    utilization_pct: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemChannelAllocationValue(TypedDict, total=False):
+    committed: NotRequired[builtins.float]
+    pct: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemSummary(TypedDict, total=False):
+    checks_performed: NotRequired[builtins.int]
+    outcomes_reported: NotRequired[builtins.int]
+    adjustments_reported: NotRequired[builtins.int]
+    adjustments_verified: NotRequired[builtins.int]
+    statuses: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryStatuses]
+    findings_count: NotRequired[builtins.int]
+    escalations: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemSummaryEscalationsItem]]
+    drift_metrics: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryDriftMetrics]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    type: Required[Literal['check', 'outcome', 'adjustment']]
+    timestamp: Required[builtins.str]
+    plan_id: NotRequired[builtins.str]
+    caller: NotRequired[builtins.str]
+    tool: NotRequired[builtins.str]
+    verdict: NotRequired[Literal['approved', 'denied', 'conditions']]
+    check_type: NotRequired[Literal['intent', 'execution']]
+    mode: NotRequired[Literal['audit', 'advisory', 'enforce']]
+    explanation: NotRequired[builtins.str]
+    policies_evaluated: NotRequired[builtins.list[builtins.str]]
+    categories_evaluated: NotRequired[builtins.list[builtins.str]]
+    findings: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItemFindingsItem]]
+    delivery_statement: NotRequired[_GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryStatement]
+    outcome: NotRequired[Literal['completed', 'failed', 'delivery']]
+    outcome_id: NotRequired[builtins.str]
+    seller_adjustment_id: NotRequired[builtins.str]
+    adjustment_type: NotRequired[Literal['decommitment', 'refund', 'credit', 'makegood']]
+    amount: NotRequired[_GetPlanAuditLogsResponsePlansItemEntriesItemAmount]
+    headroom_restored: NotRequired[builtins.float]
+    reason: NotRequired[builtins.str]
+    effective_at: NotRequired[builtins.str]
+    committed_budget: NotRequired[builtins.float]
+    reported_committed_budget: NotRequired[builtins.float]
+    seller_reference: NotRequired[builtins.str]
+    delivery: NotRequired[_GetPlanAuditLogsResponsePlansItemEntriesItemDelivery]
+    governance_context: NotRequired[builtins.str]
+    plan_hash: NotRequired[builtins.str]
+    runtime_attestations: NotRequired[builtins.list[_GetPlanAuditLogsResponsePlansItemEntriesItemRuntimeAttestationsItem]]
+    runtime_attestation_binding_digest: NotRequired[builtins.str]
+    purchase_type: NotRequired[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']]
+    outcome_status: NotRequired[builtins.str]
+    delivery_reconciliation_status: NotRequired[Literal['consistent', 'measurement_variance', 'disputed', 'unmatched', 'closed_unresolved']]
+    delivery_period_state: NotRequired[Literal['open', 'closed']]
+    adjustment_state: NotRequired[Literal['reported', 'verified', 'disputed']]
+    verified_amount: NotRequired[builtins.float]
+    evidence: NotRequired[_GetPlanAuditLogsResponsePlansItemEntriesItemEvidence]
+    reviewed_by: NotRequired[builtins.str]
+    reviewed_at: NotRequired[builtins.str]
+    review_reason: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemGovernedActionsItem(TypedDict, total=False):
+    governance_context: Required[builtins.str]
+    purchase_type: Required[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']]
+    status: Required[Literal['active', 'suspended', 'completed']]
+    committed: Required[builtins.float]
+    adjustments_reported: NotRequired[builtins.float]
+    adjustments_verified: NotRequired[builtins.float]
+    net_cost: NotRequired[builtins.float]
+    headroom_restored: NotRequired[builtins.float]
+    net_committed: NotRequired[builtins.float]
+    seller_reported_spend: NotRequired[builtins.float]
+    buyer_observed_spend: NotRequired[builtins.float]
+    delivery_reporting_period: NotRequired[_GetPlanAuditLogsResponsePlansItemGovernedActionsItemDeliveryReportingPeriod]
+    conservative_exposure: NotRequired[builtins.float]
+    delivery_reconciliation_status: NotRequired[Literal['consistent', 'measurement_variance', 'disputed', 'unmatched', 'closed_unresolved']]
+    delivery_period_state: NotRequired[Literal['open', 'closed']]
+    check_count: Required[builtins.int]
+    seller_reference: NotRequired[builtins.str]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant1(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant2(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductPublisherPropertiesItemVariant3(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['by_tag']]
+    property_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1 | _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2 | _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3 | _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4]
+
+class _ExternalCoreProductFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1 | _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2 | _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3 | _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4]
+
+class _ExternalCoreProductFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1 | _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2 | _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3 | _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4]
+
+class _ExternalCoreProductFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCoreProductFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCoreProductFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCoreProductFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCoreProductFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCoreProductFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCoreProductFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCoreProductFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCoreProductFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCoreProductFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePlacement(TypedDict, total=False):
+    kind: Required[Literal['publisher_ref', 'seller_inline']]
+    placement_id: Required[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    mode: Required[Literal['targetable', 'included']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_options: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1 | _ExternalCorePlacementFormatOptionsItemVariant2 | _ExternalCorePlacementFormatOptionsItemVariant3 | _ExternalCorePlacementFormatOptionsItemVariant4 | _ExternalCorePlacementFormatOptionsItemVariant5 | _ExternalCorePlacementFormatOptionsItemVariant6 | _ExternalCorePlacementFormatOptionsItemVariant7 | _ExternalCorePlacementFormatOptionsItemVariant8 | _ExternalCorePlacementFormatOptionsItemVariant9 | _ExternalCorePlacementFormatOptionsItemVariant10 | _ExternalCorePlacementFormatOptionsItemVariant11 | _ExternalCorePlacementFormatOptionsItemVariant12 | _ExternalCorePlacementFormatOptionsItemVariant13]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['vcpm']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpc']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpcv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpv']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.bool]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant5Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant6(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpp']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant6Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant7(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['cpa']]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: NotRequired[builtins.str]
+    currency: Required[builtins.str]
+    fixed_price: Required[builtins.float]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant8(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['revenue_share']]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    event_source_id: Required[builtins.str]
+    commission_rate: Required[builtins.float]
+    currency: Required[builtins.str]
+    commission_basis_description: Required[builtins.str]
+
+class _ExternalCoreProductPricingOptionsItemVariant9(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['flat_rate']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: NotRequired[_ExternalCoreProductPricingOptionsItemVariant9Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreProductPricingOptionsItemVariant10(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    pricing_model: Required[Literal['time']]
+    currency: Required[builtins.str]
+    fixed_price: NotRequired[builtins.float]
+    floor_price: NotRequired[builtins.float]
+    price_guidance: NotRequired[_ExternalPricingOptionsPriceGuidance]
+    parameters: Required[_ExternalCoreProductPricingOptionsItemVariant10Parameters]
+    min_spend_per_package: NotRequired[builtins.float]
+    price_breakdown: NotRequired[_ExternalPricingOptionsPriceBreakdown]
+    eligible_adjustments: NotRequired[builtins.list[Literal['fee', 'discount', 'commission', 'settlement']]]
+
+class _ExternalCoreDeliveryForecast(TypedDict, total=False):
+    points: Required[builtins.list[_ExternalCoreForecastPoint]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreOutcomeMeasurement(TypedDict, total=False):
+    type: Required[builtins.str]
+    attribution: Required[builtins.str]
+    window: NotRequired[_ExternalCoreOutcomeMeasurementWindow]
+    reporting: Required[builtins.str]
+
+class _ExternalCoreProductDeliveryMeasurement(TypedDict, total=False):
+    vendors: NotRequired[builtins.list[_ExternalCoreBrandRef]]
+    provider: NotRequired[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _ExternalCoreCancellationPolicy(TypedDict, total=False):
+    notice_period: Required[_ExternalCoreDuration]
+    cancellation_fee: Required[_ExternalCoreCancellationPolicyCancellationFee]
+
+class _ExternalCoreProductAllowedAction(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']]
+    modes: Required[builtins.list[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]]
+    allowed_statuses: NotRequired[builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ExternalCoreReportingCapabilities(TypedDict, total=False):
+    available_reporting_frequencies: Required[builtins.list[Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign']]]
+    expected_delay_minutes: Required[builtins.int]
+    timezone: Required[builtins.str]
+    supports_webhooks: Required[builtins.bool]
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    vendor_metrics: NotRequired[builtins.list[_ExternalCoreReportingCapabilitiesVendorMetricsItem]]
+    supports_creative_breakdown: NotRequired[builtins.bool]
+    supports_keyword_breakdown: NotRequired[builtins.bool]
+    supports_geo_breakdown: NotRequired[_ExternalCoreGeoBreakdownSupport]
+    supports_device_type_breakdown: NotRequired[builtins.bool]
+    supports_device_platform_breakdown: NotRequired[builtins.bool]
+    supports_audience_breakdown: NotRequired[builtins.bool]
+    supports_demographic_breakdown: NotRequired[_ExternalCoreDemographicReportingCapability]
+    supports_placement_breakdown: NotRequired[builtins.bool]
+    supports_spot_breakdown: NotRequired[_ExternalCoreSpotReportingCapability]
+    date_range_support: Required[Literal['date_range', 'lifetime_only']]
+    windowed_pull_granularities: NotRequired[builtins.list[Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign']]]
+    measurement_windows: NotRequired[builtins.list[_ExternalCoreMeasurementWindow]]
+
+class _ExternalCoreCreativePolicy(TypedDict, total=False):
+    co_branding: Required[Literal['required', 'optional', 'none']]
+    landing_page: Required[Literal['any', 'retailer_site_only', 'must_include_retailer']]
+    templates_available: Required[builtins.bool]
+    provenance_required: NotRequired[builtins.bool]
+    provenance_requirements: NotRequired[_ExternalCoreCreativePolicyProvenanceRequirements]
+    accepted_verifiers: NotRequired[builtins.list[_ExternalCoreCreativePolicyAcceptedVerifiersItem]]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant1(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant2(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    signal_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreProductDataProviderSignalsItemVariant3(TypedDict, total=False):
+    data_provider_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_tag']]
+    signal_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreSignalListing(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreSignalListingSignalRefVariant1 | _ExternalCoreSignalListingSignalRefVariant2 | _ExternalCoreSignalListingSignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreSignalListingSignalIdVariant1 | _ExternalCoreSignalListingSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_ExternalCoreSignalListingRange]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    demographic_predicate: NotRequired[_ExternalCoreDemographicPredicate]
+
+class _ExternalCoreProductSignalTargetingOption(TypedDict, total=False):
+    signal_ref: Required[_ExternalCoreProductSignalTargetingOptionSignalRefVariant1 | _ExternalCoreProductSignalTargetingOptionSignalRefVariant2 | _ExternalCoreProductSignalTargetingOptionSignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductSignalTargetingOptionSignalIdVariant1 | _ExternalCoreProductSignalTargetingOptionSignalIdVariant2]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    last_updated: NotRequired[builtins.str]
+    value_type: NotRequired[Literal['binary', 'categorical', 'numeric']]
+    categories: NotRequired[builtins.list[builtins.str]]
+    range: NotRequired[_ExternalCoreProductSignalTargetingOptionRange]
+    restricted_attributes: NotRequired[builtins.list[Literal['racial_ethnic_origin', 'political_opinions', 'religious_beliefs', 'trade_union_membership', 'health_data', 'sex_life_sexual_orientation', 'genetic_data', 'biometric_data', 'age', 'familial_status']]]
+    demographic_predicate: NotRequired[_ExternalCoreDemographicPredicate]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_status: NotRequired[Literal['ready', 'requires_activation']]
+    allowed_targeting_modes: NotRequired[builtins.list[Literal['include', 'exclude']]]
+    default_selected: NotRequired[builtins.bool]
+    selection_group: NotRequired[builtins.str]
+    pricing_options: NotRequired[builtins.list[_ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant1 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant2 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant3 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant4 | _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5]]
+
+class _ExternalCoreSignalTargetingRules(TypedDict, total=False):
+    resolution_model: NotRequired[Literal['direct_targeting', 'seller_planned']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+    max_selected_per_group: NotRequired[builtins.int]
+    max_signal_targeting_groups: NotRequired[builtins.int]
+    max_signals_per_targeting_group: NotRequired[builtins.int]
+    selection_group_rules: NotRequired[builtins.list[_ExternalCoreSignalSelectionGroupRule]]
+
+class _ExternalCoreDemographicTargetingCapability(TypedDict, total=False):
+    age: Required[_ExternalCoreDemographicTargetingCapabilityAge]
+
+class _ExternalCoreTargetingOverlaySupport(TypedDict, total=False):
+    geo_countries: NotRequired[Literal[True]]
+    geo_countries_exclude: NotRequired[Literal[True]]
+    geo_regions: NotRequired[Literal[True] | _ExternalCoreGeoRegionSupport]
+    geo_regions_exclude: NotRequired[Literal[True] | _ExternalCoreGeoRegionSupport]
+    geo_metros: NotRequired[Literal[True] | _MetroSupportVariant2]
+    geo_metros_exclude: NotRequired[Literal[True] | _MetroSupportVariant2]
+    geo_places: NotRequired[_PlaceSupport]
+    geo_places_exclude: NotRequired[_PlaceSupport]
+    geo_postal_areas: NotRequired[Literal[True] | _ExternalCorePositivePostalAreaSupport]
+    geo_postal_areas_exclude: NotRequired[Literal[True] | _ExternalCorePositivePostalAreaSupport]
+    geo_proximity: NotRequired[Literal[True] | _ExternalCoreTargetingOverlaySupportGeoProximityVariant2]
+    daypart_targets: NotRequired[Literal[True]]
+    audience_include: NotRequired[Literal[True]]
+    audience_exclude: NotRequired[Literal[True]]
+    signal_targeting_groups: NotRequired[Literal[True]]
+    demographics: NotRequired[Literal[True] | _ExternalCoreTargetingOverlaySupportDemographicsVariant2]
+    frequency_cap: NotRequired[Literal[True]]
+    property_list: NotRequired[Literal[True]]
+    property_list_exclude: NotRequired[Literal[True]]
+    collection_list: NotRequired[Literal[True]]
+    collection_list_exclude: NotRequired[Literal[True]]
+    placement_selection: NotRequired[Literal[True] | _ExternalCoreTargetingOverlaySupportPlacementSelectionVariant2]
+    age_restriction: NotRequired[Literal[True]]
+    device_platform: NotRequired[Literal[True]]
+    device_platform_exclude: NotRequired[Literal[True]]
+    device_type: NotRequired[Literal[True]]
+    device_type_exclude: NotRequired[Literal[True]]
+    browser: NotRequired[Literal[True] | _BrowserSupportVariant2]
+    browser_exclude: NotRequired[Literal[True] | _BrowserSupportVariant2]
+    store_catchments: NotRequired[Literal[True]]
+    language: NotRequired[Literal[True]]
+    keyword_targets: NotRequired[Literal[True] | _KeywordSupportVariant2]
+    negative_keywords: NotRequired[Literal[True] | _KeywordSupportVariant2]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTargetingResolution(TypedDict, total=False):
+    modifications: Required[builtins.list[_ExternalCoreProductTargetingResolutionModificationsItemVariant1 | _ExternalCoreProductTargetingResolutionModificationsItemVariant2]]
+    effective_targeting_digest: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidence(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    snapshot_id: Required[builtins.str]
+    version: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    audience: Required[_ExternalCoreAudienceCharacteristic]
+    relationship: Required[Literal['composition', 'index', 'reach_estimate']]
+    value: Required[builtins.float]
+    unit: Required[Literal['fraction', 'ratio', 'count']]
+    baseline: Required[_ExternalCoreAudienceEvidenceBaseline]
+    evidence_type: Required[Literal['measured', 'forecast', 'seller_declared']]
+    methodology: Required[Literal['observed', 'declared', 'derived', 'inferred', 'modeled', 'projected']]
+    subject_type: Required[Literal['individual', 'household', 'business', 'contextual', 'none']]
+    resolution_method: NotRequired[Literal['deterministic_id', 'probabilistic_device', 'browser', 'geographic', 'content_signal', 'mixed']]
+    provider: Required[_ExternalCoreBrandRef]
+    measurement_window: Required[_ExternalCoreDateRange]
+    sample_size: NotRequired[builtins.int]
+    confidence: NotRequired[builtins.float]
+    last_updated: Required[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    attestation_refs: NotRequired[builtins.list[_ExternalCoreAudienceEvidenceAttestationRefsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]]
+    supported_reach_units: NotRequired[builtins.list[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]]
+    supported_view_durations: NotRequired[builtins.list[builtins.float]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _ExternalCoreVendorMetricOptimization(TypedDict, total=False):
+    supported_metrics: Required[builtins.list[_ExternalCoreVendorMetricOptimizationSupportedMetric]]
+
+class _ExternalCoreMeasurementReadiness(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    required_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    missing_event_types: NotRequired[builtins.list[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]]
+    issues: NotRequired[builtins.list[_ExternalCoreDiagnosticIssue]]
+    notes: NotRequired[builtins.str]
+
+class _ExternalCoreProductConversionTracking(TypedDict, total=False):
+    action_sources: NotRequired[builtins.list[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'per_ad_spend', 'maximize_value']]]
+    platform_managed: NotRequired[builtins.bool]
+
+class _ExternalCoreProductCatalogMatch(TypedDict, total=False):
+    matched_gtins: NotRequired[builtins.list[builtins.str]]
+    matched_ids: NotRequired[builtins.list[builtins.str]]
+    matched_count: NotRequired[builtins.int]
+    submitted_count: Required[builtins.int]
+
+class _ExternalCoreProductProductCard(TypedDict, total=False):
+    image: NotRequired[_ExternalCoreAssetsImageAsset]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+
+class _ExternalCoreProductProductCardDetailed(TypedDict, total=False):
+    hero_image: NotRequired[_ExternalCoreAssetsImageAsset]
+    carousel_images: NotRequired[builtins.list[_ExternalCoreAssetsImageAsset]]
+    title: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    specifications: NotRequired[builtins.list[_ExternalCoreProductProductCardDetailedSpecificationsItem]]
+    price_label: NotRequired[builtins.str]
+    cta_label: NotRequired[builtins.str]
+    reference_assets: NotRequired[builtins.list[_ExternalCoreProductCardReferenceAsset]]
+
+class _ExternalCoreCollectionSelector(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    collection_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreInstallment(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    collection_id: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    season: NotRequired[builtins.str]
+    installment_number: NotRequired[builtins.str]
+    scheduled_at: NotRequired[builtins.str]
+    status: NotRequired[Literal['scheduled', 'tentative', 'live', 'postponed', 'cancelled', 'aired', 'published']]
+    duration_seconds: NotRequired[builtins.int]
+    flexible_end: NotRequired[builtins.bool]
+    valid_until: NotRequired[builtins.str]
+    content_rating: NotRequired[_ExternalCoreContentRating]
+    topics: NotRequired[builtins.list[builtins.str]]
+    special: NotRequired[_ExternalCoreSpecial]
+    guest_talent: NotRequired[builtins.list[_ExternalCoreTalent]]
+    ad_inventory: NotRequired[_ExternalCoreAdInventoryConfig]
+    deadlines: NotRequired[_ExternalCoreInstallmentDeadlines]
+    derivative_of: NotRequired[_ExternalCoreInstallmentDerivativeOf]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTrustedMatch(TypedDict, total=False):
+    context_match: Required[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+    dynamic_brands: NotRequired[builtins.bool]
+    providers: NotRequired[builtins.list[_ExternalCoreProductTrustedMatchProvidersItem]]
+
+class _ExternalCoreProductMaterialSubmission(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    instructions: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCatalogFieldMapping(TypedDict, total=False):
+    feed_field: NotRequired[builtins.str]
+    catalog_field: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    value: NotRequired[Any]
+    transform: NotRequired[Literal['date', 'divide', 'boolean', 'split']]
+    format: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    by: NotRequired[builtins.float]
+    separator: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductFiltersFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreProductFiltersBudgetRange(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreProductFiltersMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    code: Required[builtins.str]
+
+class _ExternalCoreProductFiltersTrustedMatch(TypedDict, total=False):
+    providers: NotRequired[builtins.list[_ExternalCoreProductFiltersTrustedMatchProvidersItem]]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+
+class _ExternalCoreMediaBuyFeatures(TypedDict, total=False):
+    inline_creative_management: NotRequired[builtins.bool]
+    property_list_filtering: NotRequired[builtins.bool]
+    catalog_management: NotRequired[builtins.bool]
+    catalog_item_availability_updates: NotRequired[builtins.bool]
+    committed_metrics_supported: NotRequired[builtins.bool]
+    seller_optimized_budget: NotRequired[builtins.bool]
+    bidding_policy: NotRequired[_ExternalCoreMediaBuyFeaturesBiddingPolicy]
+
+class _ExternalCoreProductFiltersRequiredGeoTargetingItem(TypedDict, total=False):
+    level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    country: NotRequired[builtins.str]
+    system: NotRequired[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant2 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant1 | _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_ExternalCoreProductFiltersGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant1Geometry]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_ExternalCoreProductFiltersGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant2Geometry]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreProductFiltersGeoProximityItemVariant3Radius]
+    geometry: Required[_ExternalCoreProductFiltersGeoProximityItemVariant3Geometry]
+
+class _ExternalCoreProductFiltersRequiredVendorMetricsItem(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    metric_id: NotRequired[builtins.str]
+
+class _ExternalCoreProductFiltersKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: NotRequired[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreTargetingGeoMetrosItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoMetrosExcludeItem(TypedDict, total=False):
+    system: Required[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreGeoPlaceArea(TypedDict, total=False):
+    country: Required[builtins.str]
+    system: Required[Literal['geonames', 'google_ads', 'microsoft_ads'] | builtins.str]
+    system_version: NotRequired[builtins.str]
+    place_type: Required[Literal['airport', 'borough', 'city', 'city_region', 'commune', 'county', 'district', 'municipality', 'neighborhood', 'post_town', 'prefecture', 'province', 'quarter', 'state', 'territory', 'ward'] | builtins.str]
+    values: Required[builtins.list[builtins.str]]
+    value_labels: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDaypartTarget(TypedDict, total=False):
+    days: Required[builtins.list[Literal['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']]]
+    start_hour: Required[builtins.int]
+    end_hour: Required[builtins.int]
+    label: NotRequired[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroups(TypedDict, total=False):
+    operator: Required[Literal['all']]
+    groups: Required[builtins.list[_ExternalCorePackageSignalTargetingGroup]]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3(TypedDict, total=False):
+    signal_ref: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant2 | _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant1 | _ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalCoreDemographicTargetingIntent(TypedDict, total=False):
+    age: Required[_ExternalCoreDemographicTargetingIntentAge]
+
+class _ExternalCoreCollectionListRef(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    list_id: Required[builtins.str]
+    auth_token: NotRequired[builtins.str]
+
+class _ExternalCoreTargetingPlacementSelectionVariant1(TypedDict, total=False):
+    mode: Required[Literal['selected']]
+    placement_refs: Required[builtins.list[_ExternalCoreTargetingPlacementSelectionVariant1PlacementRefsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingPlacementSelectionVariant2(TypedDict, total=False):
+    mode: Required[Literal['default']]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingAgeRestriction(TypedDict, total=False):
+    min: Required[builtins.int]
+    verification_required: NotRequired[builtins.bool]
+    accepted_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _ExternalCoreTargetingStoreCatchmentsItem(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    store_ids: NotRequired[builtins.list[builtins.str]]
+    catchment_ids: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: Required[_ExternalCoreTargetingGeoProximityItemVariant1TravelTime]
+    transport_mode: Required[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant1Radius]
+    geometry: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant1Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2(TypedDict, total=False):
+    lat: Required[builtins.float]
+    lng: Required[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant2TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: Required[_ExternalCoreTargetingGeoProximityItemVariant2Radius]
+    geometry: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant2Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3(TypedDict, total=False):
+    lat: NotRequired[builtins.float]
+    lng: NotRequired[builtins.float]
+    label: NotRequired[builtins.str]
+    travel_time: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant3TravelTime]
+    transport_mode: NotRequired[Literal['walking', 'cycling', 'driving', 'public_transport']]
+    radius: NotRequired[_ExternalCoreTargetingGeoProximityItemVariant3Radius]
+    geometry: Required[_ExternalCoreTargetingGeoProximityItemVariant3Geometry]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingKeywordTargetsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalCoreTargetingNegativeKeywordsItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreGeoRegionRequirement(TypedDict, total=False):
+    countries: Required[builtins.dict[builtins.str, _ExternalCoreGeoRegionRequirementCountriesValueVariant1 | _ExternalCoreGeoRegionRequirementCountriesValueVariant2]]
+
+class _MetroRequirementVariant2(TypedDict, total=False):
+    systems: Required[builtins.list[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]]
+
+class _ExternalCoreGeoPlaceRequirement(TypedDict, total=False):
+    systems: Required[builtins.dict[builtins.str, _CatalogRequirement]]
+
+class _ExternalCorePositivePostalAreaSupport(TypedDict, total=False):
+    US: NotRequired[builtins.list[Literal['zip', 'zip_plus_four']]]
+    GB: NotRequired[builtins.list[Literal['outward', 'full']]]
+    CA: NotRequired[builtins.list[Literal['fsa', 'full']]]
+    DE: NotRequired[builtins.list[Literal['plz']]]
+    CH: NotRequired[builtins.list[Literal['plz']]]
+    AT: NotRequired[builtins.list[Literal['plz']]]
+    FR: NotRequired[builtins.list[Literal['code_postal']]]
+    AU: NotRequired[builtins.list[Literal['postcode']]]
+    BR: NotRequired[builtins.list[Literal['cep']]]
+    IN: NotRequired[builtins.list[Literal['pin']]]
+    ZA: NotRequired[builtins.list[Literal['postal_code']]]
+    us_zip: NotRequired[Literal[True]]
+    us_zip_plus_four: NotRequired[Literal[True]]
+    gb_outward: NotRequired[Literal[True]]
+    gb_full: NotRequired[Literal[True]]
+    ca_fsa: NotRequired[Literal[True]]
+    ca_full: NotRequired[Literal[True]]
+    de_plz: NotRequired[Literal[True]]
+    fr_code_postal: NotRequired[Literal[True]]
+    au_postcode: NotRequired[Literal[True]]
+    ch_plz: NotRequired[Literal[True]]
+    at_plz: NotRequired[Literal[True]]
+
+class _ExternalCoreTargetingOverlayRequirementsGeoProximityVariant2(TypedDict, total=False):
+    radius: NotRequired[Literal[True]]
+    travel_time: NotRequired[Literal[True]]
+    geometry: NotRequired[Literal[True]]
+    transport_modes: NotRequired[builtins.list[Literal['walking', 'cycling', 'driving', 'public_transport']]]
+
+class _ExternalCoreTargetingOverlayRequirementsDemographicsVariant2(TypedDict, total=False):
+    age: Required[Literal[True]]
+
+class _BrowserRequirementVariant2(TypedDict, total=False):
+    families: Required[builtins.list[Literal['chrome', 'safari', 'firefox', 'edge', 'opera', 'samsung_internet', 'android_webview', 'other', 'unknown']]]
+
+class _KeywordRequirementVariant2(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _ExternalCoreProductAllocation(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    allocation_percentage: NotRequired[builtins.float]
+    min_spend_target_percentage: NotRequired[builtins.float]
+    max_spend_percentage: NotRequired[builtins.float]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    pricing_option_id: NotRequired[builtins.str]
+    rationale: NotRequired[builtins.str]
+    sequence: NotRequired[builtins.int]
+    tags: NotRequired[builtins.list[builtins.str]]
+    start_time: NotRequired[builtins.str]
+    end_time: NotRequired[builtins.str]
+    daypart_targets: NotRequired[builtins.list[_ExternalCoreDaypartTarget]]
+    forecast: NotRequired[_ExternalCoreDeliveryForecast]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProposalBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _ExternalCoreProposalBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalCoreProposalTotalBudgetGuidance(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    recommended: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _GetProductsResponseIncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetProductsResponseFilterDiagnosticsExcludedByValue(TypedDict, total=False):
+    count: Required[builtins.int]
+    values: NotRequired[builtins.list[builtins.str | builtins.dict[builtins.str, Any]]]
+    notes: NotRequired[builtins.str]
+
+class _GetRightsResponseRightsItemExclusivityStatus(TypedDict, total=False):
+    available: NotRequired[builtins.bool]
+    existing_exclusives: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalBrandRightsPricingOption(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    model: Required[Literal['cpm', 'vcpm', 'cpc', 'cpcv', 'cpv', 'cpp', 'cpa', 'revenue_share', 'flat_rate', 'time']]
+    price: Required[builtins.float]
+    currency: Required[builtins.str]
+    uses: Required[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    period: NotRequired[Literal['daily', 'weekly', 'monthly', 'quarterly', 'annual', 'one_time']]
+    impression_cap: NotRequired[builtins.int]
+    overage_cpm: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetRightsResponseRightsItemPreviewAssetsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    usage: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Never]
+    signal_id: Required[builtins.str]
+    data_provider_domain: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Never]
+    signal_id: Required[builtins.str]
+    signal_source_url: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant4(TypedDict, total=False):
+    scope: Required[Never]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant5(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant6(TypedDict, total=False):
+    scope: Required[Never]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+    signal_source_url: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant7(TypedDict, total=False):
+    scope: Required[Never]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant8(TypedDict, total=False):
+    scope: Required[Never]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+    data_provider_domain: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalRefVariant9(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetSignalsResponseSignalsItemDemographicPredicate(TypedDict, total=False):
+    age: Required[_ExternalCoreDemographicAgeRange]
+
+class _GetSignalsResponseSignalsItemTaxonomy(TypedDict, total=False):
+    ref: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    segtax: NotRequired[builtins.int]
+    etag: NotRequired[builtins.str]
+    values: Required[builtins.list[_GetSignalsResponseSignalsItemTaxonomyValuesItem]]
+    value_mappings: NotRequired[builtins.list[_GetSignalsResponseSignalsItemTaxonomyValueMappingsItem]]
+    parent_match_behavior: NotRequired[Literal['exact_only', 'descendants_supported', 'unknown']]
+
+class _GetSignalsResponseSignalsItemOnboarder(TypedDict, total=False):
+    match_keys: Required[builtins.list[Literal['name', 'address', 'email', 'postal', 'lat_long', 'mobile_id', 'cookie_id', 'ip', 'customer_id', 'phone']]]
+    pre_onboarding_audience_expansion: NotRequired[builtins.bool]
+    pre_onboarding_device_expansion: NotRequired[builtins.bool]
+    pre_onboarding_precision_level: NotRequired[Literal['individual', 'household', 'business', 'geography']]
+
+class _GetSignalsResponseSignalsItemModeling(TypedDict, total=False):
+    method: Required[Literal['lookalike', 'supervised', 'embedding', 'rules']]
+    seed_source: Required[_GetSignalsResponseSignalsItemModelingSeedSource]
+    training_data_jurisdictions: Required[builtins.list[builtins.str]]
+    ai_act_risk_class: Required[Literal['minimal', 'limited', 'high_risk']]
+    disclosure: NotRequired[_ExternalCoreSignalModelingDisclosure]
+
+class _GetSignalsResponseSignalsItemDataSubjectRights(TypedDict, total=False):
+    upstream_source_domain: NotRequired[builtins.str]
+    channels: Required[builtins.list[_GetSignalsResponseSignalsItemDataSubjectRightsChannelsItem]]
+    response_sla_days: NotRequired[builtins.int]
+    ccpa_opt_out_url: NotRequired[builtins.str]
+
+class _ExternalCoreSignalCoverageForecast(TypedDict, total=False):
+    points: Required[builtins.list[_ExternalCoreSignalCoverageForecastPointsItem]]
+    forecast_range_unit: Required[Literal['availability']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    scope: Required[_ExternalCoreSignalCoverageForecastScope]
+    bucket_semantics: Required[Literal['exclusive', 'overlapping']]
+    bucket_completeness: Required[Literal['complete', 'partial']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['platform']]
+    platform: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    account: NotRequired[builtins.str]
+    is_live: Required[builtins.bool]
+    activation_key: NotRequired[_GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant1 | _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant2]
+    estimated_activation_duration_minutes: NotRequired[builtins.float]
+    deployed_at: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_GetSignalsResponseSignalsItemPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetSignalsResponseIncompleteItemEstimatedWait(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetTaskStatusResponseErrorDetails(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    operation: NotRequired[builtins.str]
+    specific_context: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _IdentityMatchRequestIdentitiesItemAttestation(TypedDict, total=False):
+    issuer: Required[_ExternalCoreBrandRef]
+    scheme: Required[builtins.str]
+    relying_party_id: NotRequired[builtins.str]
+    action: NotRequired[builtins.str]
+    claims: Required[builtins.list[Literal['unique_human', 'age_over_13', 'age_over_16', 'age_over_18', 'age_over_21']]]
+    verification_level: NotRequired[Literal['orb', 'device', 'document']]
+    signal_binding: NotRequired[builtins.str]
+    proof: Required[builtins.dict[builtins.str, Any]]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationIdentityChangeVariant1(TypedDict, total=False):
+    status: Required[Literal['pending_approval']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    requested_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationIdentityChangeVariant2(TypedDict, total=False):
+    status: Required[Literal['rejected']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    requested_at: NotRequired[builtins.str]
+    reason: Required[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _ExternalCoreAccountWithAuthorizationReportingBucket(TypedDict, total=False):
+    protocol: Required[Literal['s3', 'gcs', 'azure_blob']]
+    bucket: Required[builtins.str]
+    prefix: NotRequired[builtins.str]
+    region: NotRequired[builtins.str]
+    format: NotRequired[Literal['jsonl', 'csv', 'parquet', 'avro', 'orc']]
+    compression: NotRequired[Literal['gzip', 'none']]
+    file_retention_days: Required[builtins.int]
+    setup_instructions: NotRequired[builtins.str]
+
+class _ExternalCoreAccountAuthorization(TypedDict, total=False):
+    allowed_tasks: Required[builtins.list[builtins.str]]
+    field_scopes: NotRequired[builtins.dict[builtins.str, builtins.list[builtins.str]]]
+    scope_name: NotRequired[Literal['attestation_verifier'] | builtins.str]
+    read_only: NotRequired[builtins.bool]
+
+class _ExternalContentStandardsContentStandardsCalibrationExemplars(TypedDict, total=False):
+    fail: NotRequired[builtins.list[_ExternalContentStandardsArtifact]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalContentStandardsContentStandardsPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatRendersItemVariant1(TypedDict, total=False):
+    role: Required[builtins.str]
+    parameters_from_format_id: NotRequired[builtins.bool]
+    dimensions: Required[_ExternalCoreFormatRendersItemVariant1Dimensions]
+
+class _ExternalCoreFormatRendersItemVariant2(TypedDict, total=False):
+    role: Required[builtins.str]
+    parameters_from_format_id: Required[Literal[True]]
+    dimensions: NotRequired[_ExternalCoreFormatRendersItemVariant2Dimensions]
+
+class _ExternalCoreFormatAssetsItemVariant1(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['image']]
+    requirements: NotRequired[_ExternalCoreRequirementsImageAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant2(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['video']]
+    requirements: NotRequired[_ExternalCoreRequirementsVideoAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant3(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['audio']]
+    requirements: NotRequired[_ExternalCoreRequirementsAudioAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant4(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['text']]
+    requirements: NotRequired[_ExternalCoreRequirementsTextAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant5(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['markdown']]
+    requirements: NotRequired[_ExternalCoreRequirementsMarkdownAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant6(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['html']]
+    requirements: NotRequired[_ExternalCoreRequirementsHtmlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant7(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['css']]
+    requirements: NotRequired[_ExternalCoreRequirementsCssAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant8(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['javascript']]
+    requirements: NotRequired[_ExternalCoreRequirementsJavascriptAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant9(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['zip']]
+
+class _ExternalCoreFormatAssetsItemVariant10(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['vast']]
+    requirements: NotRequired[_ExternalCoreRequirementsVastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant11(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['daast']]
+    requirements: NotRequired[_ExternalCoreRequirementsDaastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant12(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['url']]
+    requirements: NotRequired[_ExternalCoreRequirementsUrlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant13(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['webhook']]
+    requirements: NotRequired[_ExternalCoreRequirementsWebhookAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant14(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['brief']]
+
+class _ExternalCoreFormatAssetsItemVariant15(TypedDict, total=False):
+    item_type: Required[Literal['individual']]
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_group_id: NotRequired[builtins.str]
+    asset_type: Required[Literal['catalog']]
+    requirements: NotRequired[_ExternalCoreRequirementsCatalogRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16(TypedDict, total=False):
+    item_type: Required[Literal['repeatable_group']]
+    asset_group_id: Required[builtins.str]
+    required: Required[builtins.bool]
+    min_count: Required[builtins.int]
+    max_count: Required[builtins.int]
+    selection_mode: NotRequired[Literal['sequential', 'optimize']]
+    assets: Required[builtins.list[_ExternalCoreFormatAssetsItemVariant16AssetsItemVariant1 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant2 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant3 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant4 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant5 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant6 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant7 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant8 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant9 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant10 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant11 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant12 | _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant13]]
+
+class _ExternalCoreFormatFormatCard(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatAccessibility(TypedDict, total=False):
+    wcag_level: Required[Literal['A', 'AA', 'AAA']]
+    requires_accessible_assets: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatDisclosureCapabilitiesItem(TypedDict, total=False):
+    position: Required[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]
+    persistence: Required[builtins.list[Literal['continuous', 'initial', 'flexible']]]
+
+class _ExternalCoreFormatFormatCardDetailed(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    manifest: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreFormatPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalProjectionRef(TypedDict, total=False):
+    kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    slots_override: NotRequired[builtins.list[_ExternalCoreCanonicalProjectionSlotOverride]]
+
+class _ExternalCoreFormatCanonicalParametersVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1 | _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2 | _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3 | _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4]
+
+class _ExternalCoreFormatCanonicalParametersVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1 | _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2 | _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3 | _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4]
+
+class _ExternalCoreFormatCanonicalParametersVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1 | _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2 | _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3 | _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4]
+
+class _ExternalCoreFormatCanonicalParametersVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCoreFormatCanonicalParametersVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCoreFormatCanonicalParametersVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCoreFormatCanonicalParametersVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCoreFormatCanonicalParametersVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCoreFormatCanonicalParametersVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCoreFormatCanonicalParametersVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCoreFormatCanonicalParametersVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCoreFormatCanonicalParametersVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCoreFormatCanonicalParametersVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeFiltersAccountsItemVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalCoreCreativeFiltersAccountsItemVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ListCreativesResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: NotRequired[builtins.str]
+    direction: NotRequired[Literal['asc', 'desc']]
+
+class _ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreCreativeLocalizationReadback(TypedDict, total=False):
+    default_locale_variant_id: Required[builtins.str]
+    unmatched_locale_action: Required[Literal['serve_default', 'do_not_serve']]
+    locale_matching: Required[Literal['rfc4647_lookup']]
+    locale_fallbacks: NotRequired[builtins.list[_ExternalCoreCreativeLocalizationReadbackLocaleFallbacksItem]]
+    variants: Required[builtins.list[_ExternalCoreCreativeLocalizationReadbackVariantsItemVariant1 | _ExternalCoreCreativeLocalizationReadbackVariantsItemVariant2]]
+
+class _ListCreativesResponseCreativesItemVariant1LocalizationUnavailable(TypedDict, total=False):
+    errors: Required[builtins.list[_ExternalCoreError]]
+    retryable: Required[builtins.bool]
+
+class _ExternalCoreRightsAttestationEvaluation(TypedDict, total=False):
+    rights_id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    reference: Required[_ExternalCoreRightsAttestationEvaluationReference]
+    evaluation: Required[_ExternalCoreRightsAttestationEvaluationEvaluation]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeVariable(TypedDict, total=False):
+    variable_id: Required[builtins.str]
+    name: Required[builtins.str]
+    variable_type: Required[Literal['text', 'image', 'video', 'audio', 'url', 'number', 'boolean', 'color', 'date']]
+    default_value: NotRequired[builtins.str]
+    required: NotRequired[builtins.bool]
+
+class _ListCreativesResponseCreativesItemVariant1Assignments(TypedDict, total=False):
+    assignment_count: Required[builtins.int]
+    returned_assignment_count: NotRequired[builtins.int]
+    matching_assignment_count: NotRequired[builtins.int]
+    assignments_truncated: NotRequired[builtins.bool]
+    assigned_packages: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant1AssignmentsAssignedPackagesItem]]
+
+class _ListCreativesResponseCreativesItemVariant1Snapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.int]
+    last_served: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1ItemsItemVariant1(TypedDict, total=False):
+    asset_kind: Required[Literal['media']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content_uri: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant1ItemsItemVariant2(TypedDict, total=False):
+    asset_kind: Required[Literal['text']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content: Required[builtins.str | builtins.list[builtins.str]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1Purge(TypedDict, total=False):
+    kind: Required[Literal['soft']]
+    at: Required[builtins.str]
+    reason_code: Required[Literal['review_passed', 'review_failure', 'processing_failure', 'seller_rereview', 'policy_revocation', 'content_drift', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_deleted', 'takedown_request', 'advertiser_request', 'seller_archive', 'account_closed', 'account_suspended', 'retention_expired', 'legal_erasure']]
+
+class _ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ListCreativesResponseCreativesItemVariant2LocalizationUnavailable(TypedDict, total=False):
+    errors: Required[builtins.list[_ExternalCoreError]]
+    retryable: Required[builtins.bool]
+
+class _ListCreativesResponseCreativesItemVariant2Assignments(TypedDict, total=False):
+    assignment_count: Required[builtins.int]
+    returned_assignment_count: NotRequired[builtins.int]
+    matching_assignment_count: NotRequired[builtins.int]
+    assignments_truncated: NotRequired[builtins.bool]
+    assigned_packages: NotRequired[builtins.list[_ListCreativesResponseCreativesItemVariant2AssignmentsAssignedPackagesItem]]
+
+class _ListCreativesResponseCreativesItemVariant2Snapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.int]
+    last_served: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2ItemsItemVariant1(TypedDict, total=False):
+    asset_kind: Required[Literal['media']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content_uri: Required[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2ItemsItemVariant2(TypedDict, total=False):
+    asset_kind: Required[Literal['text']]
+    asset_type: Required[builtins.str]
+    asset_id: Required[builtins.str]
+    content: Required[builtins.str | builtins.list[builtins.str]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant2Purge(TypedDict, total=False):
+    kind: Required[Literal['soft']]
+    at: Required[builtins.str]
+    reason_code: Required[Literal['review_passed', 'review_failure', 'processing_failure', 'seller_rereview', 'policy_revocation', 'content_drift', 'identity_authorization_revoked', 'identity_authorization_expired', 'source_private', 'source_deleted', 'takedown_request', 'advertiser_request', 'seller_archive', 'account_closed', 'account_suspended', 'retention_expired', 'legal_erasure']]
+
+class _ListProductsRequestPushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _ExternalCoreProductOfferFilters(TypedDict, total=False):
+    delivery_type: NotRequired[Literal['guaranteed', 'non_guaranteed']]
+    exclusivity: NotRequired[Literal['none', 'category', 'exclusive']]
+    is_fixed_price: NotRequired[builtins.bool]
+    pricing_structures: NotRequired[builtins.list[Literal['fixed', 'auction', 'contingent']]]
+    pricing_currencies: NotRequired[builtins.list[builtins.str]]
+    format_kinds: NotRequired[builtins.list[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]]
+    format_option_refs: NotRequired[builtins.list[_ExternalCoreProductOfferFiltersFormatOptionRefsItemVariant1 | _ExternalCoreProductOfferFiltersFormatOptionRefsItemVariant2]]
+    standard_formats_only: NotRequired[builtins.bool]
+    min_exposures: NotRequired[builtins.int]
+    start_date: NotRequired[builtins.str]
+    end_date: NotRequired[builtins.str]
+    budget_range: NotRequired[_ExternalCoreBudgetRange]
+    countries: NotRequired[builtins.list[builtins.str]]
+    property_list: NotRequired[_ExternalCorePropertyListRef]
+    channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+    trusted_match: NotRequired[_ExternalCoreProductOfferFiltersTrustedMatch]
+    required_features: NotRequired[_ExternalCoreProductOfferFiltersRequiredFeatures]
+    required_performance_standards: NotRequired[builtins.list[_ExternalCoreProductOfferFiltersRequiredPerformanceStandardsItem]]
+    required_metrics: NotRequired[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    required_vendor_metrics: NotRequired[builtins.list[_ExternalCoreProductOfferFiltersRequiredVendorMetricsItem]]
+    audience_evidence_requirements: NotRequired[_ExternalCoreProductAudienceEvidenceRequirements]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCatalogSelection(TypedDict, total=False):
+    catalog_id: Required[builtins.str]
+    type: NotRequired[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    ids: NotRequired[builtins.list[builtins.str]]
+    gtins: NotRequired[builtins.list[builtins.str]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    category: NotRequired[builtins.str]
+    query: NotRequired[builtins.str]
+
+class _ExternalCoreCanonicalProductPublisherPropertiesItemVariant1(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['all']]
+
+class _ExternalCoreCanonicalProductPublisherPropertiesItemVariant2(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    selection_type: Required[Literal['by_id']]
+    property_ids: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreCanonicalProductPublisherPropertiesItemVariant3(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    publisher_domains: NotRequired[builtins.list[builtins.str]]
+    selection_type: Required[Literal['by_tag']]
+    property_tags: Required[builtins.list[builtins.str]]
+
+class _ExternalCoreCanonicalFormatOption(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+    format_shape: NotRequired[builtins.str]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+
+class _ExternalCoreCanonicalPlacement(TypedDict, total=False):
+    kind: Required[Literal['publisher_ref', 'seller_inline']]
+    placement_id: Required[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    description: NotRequired[builtins.str]
+    mode: Required[Literal['targetable', 'included']]
+    tags: NotRequired[builtins.list[builtins.str]]
+    format_options: NotRequired[builtins.list[_ExternalCoreCanonicalFormatOption]]
+    video_placement_types: NotRequired[builtins.list[Literal['instream', 'accompanying_content', 'interstitial', 'standalone']]]
+    audio_distribution_types: NotRequired[builtins.list[Literal['music_streaming_service', 'fm_am_broadcast', 'podcast', 'catch_up_radio', 'web_radio', 'video_game', 'text_to_speech']]]
+    sponsored_placement_types: NotRequired[builtins.list[Literal['sponsored_search', 'sponsored_display', 'sponsored_native']]]
+    social_placement_surfaces: NotRequired[builtins.list[Literal['feed', 'stories', 'short_video', 'explore', 'search']]]
+
+class _ExternalCoreCanonicalDeliveryForecast(TypedDict, total=False):
+    points: Required[builtins.list[_ExternalCoreCanonicalForecastPoint]]
+    forecast_range_unit: NotRequired[Literal['spend', 'availability', 'reach_freq', 'weekly', 'daily', 'clicks', 'conversions', 'package']]
+    method: Required[Literal['estimate', 'modeled', 'guaranteed']]
+    currency: Required[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: NotRequired[builtins.str]
+    measurement_source: NotRequired[builtins.str]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    generated_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalReportingCapabilities(TypedDict, total=False):
+    available_reporting_frequencies: Required[builtins.list[Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign']]]
+    expected_delay_minutes: Required[builtins.int]
+    timezone: Required[builtins.str]
+    supports_webhooks: Required[builtins.bool]
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+    vendor_metrics: NotRequired[builtins.list[_ExternalCoreCanonicalReportingCapabilitiesVendorMetricsItem]]
+    supports_creative_breakdown: NotRequired[builtins.bool]
+    supports_keyword_breakdown: NotRequired[builtins.bool]
+    supports_geo_breakdown: NotRequired[_ExternalCoreGeoBreakdownSupport]
+    supports_device_type_breakdown: NotRequired[builtins.bool]
+    supports_device_platform_breakdown: NotRequired[builtins.bool]
+    supports_audience_breakdown: NotRequired[builtins.bool]
+    supports_demographic_breakdown: NotRequired[_ExternalCoreDemographicReportingCapability]
+    supports_placement_breakdown: NotRequired[builtins.bool]
+    supports_spot_breakdown: NotRequired[_ExternalCoreSpotReportingCapability]
+    date_range_support: Required[Literal['date_range', 'lifetime_only']]
+    windowed_pull_granularities: NotRequired[builtins.list[Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign']]]
+    measurement_windows: NotRequired[builtins.list[_ExternalCoreMeasurementWindow]]
+
+class _ExternalCoreCanonicalAudienceEvidence(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    snapshot_id: Required[builtins.str]
+    version: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    audience: Required[_ExternalCoreAudienceCharacteristic]
+    relationship: Required[Literal['composition', 'index', 'reach_estimate']]
+    value: Required[builtins.float]
+    unit: Required[Literal['fraction', 'ratio', 'count']]
+    baseline: Required[_ExternalCoreCanonicalAudienceEvidenceBaseline]
+    evidence_type: Required[Literal['measured', 'forecast', 'seller_declared']]
+    methodology: Required[Literal['observed', 'declared', 'derived', 'inferred', 'modeled', 'projected']]
+    subject_type: Required[Literal['individual', 'household', 'business', 'contextual', 'none']]
+    resolution_method: NotRequired[Literal['deterministic_id', 'probabilistic_device', 'browser', 'geographic', 'content_signal', 'mixed']]
+    provider: Required[_ExternalCoreBrandKey]
+    measurement_window: Required[_ExternalCoreDateRange]
+    sample_size: NotRequired[builtins.int]
+    confidence: NotRequired[builtins.float]
+    last_updated: Required[builtins.str]
+    methodology_url: NotRequired[builtins.str]
+    attestation_digests: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalAudienceEvidenceSelection(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    snapshot_id: Required[builtins.str]
+    version: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    decision_use: Required[Literal['recommendation', 'eligibility', 'package_construction']]
+    evidence: NotRequired[_ExternalCoreCanonicalAudienceEvidence]
+    verified_attestation_digests: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalProductCatalogMatch(TypedDict, total=False):
+    matched_gtins: NotRequired[builtins.list[builtins.str]]
+    matched_ids: NotRequired[builtins.list[builtins.str]]
+    matched_count: NotRequired[builtins.int]
+    submitted_count: Required[builtins.int]
+
+class _ExternalCoreCanonicalProductAction(TypedDict, total=False):
+    action: Required[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'update_catalog_assignments', 'update_keywords', 'update_optimization_goals', 'update_impression_goal', 'update_spend_target', 'update_reporting_webhook', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages']]
+    modes: Required[builtins.list[Literal['self_serve', 'conditional_self_serve', 'requires_approval']]]
+    allowed_statuses: NotRequired[builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']]]
+    sla: NotRequired[_ExternalCoreSlaWindow]
+    terms_ref: NotRequired[builtins.str]
+
+class _ExternalCoreDuration(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ListTasksResponseQuerySummaryDomainBreakdown(TypedDict, total=False):
+    signals: NotRequired[builtins.int]
+    creative: NotRequired[builtins.int]
+
+class _ListTasksResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: Required[builtins.str]
+    direction: Required[Literal['asc', 'desc']]
+
+class _ExternalCoreTransformerVoiceSynthesisRefItem(TypedDict, total=False):
+    brand_agent: Required[_ExternalCoreTransformerVoiceSynthesisRefItemBrandAgent]
+    voice_id: Required[builtins.str]
+    rights_id: NotRequired[builtins.str]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant1 | _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant2 | _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant3 | _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant4]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant1 | _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant2 | _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant3 | _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant4]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant1 | _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant2 | _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant3 | _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant4]
+
+class _ExternalCoreTransformerInputFormatsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCoreTransformerInputFormatsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCoreTransformerInputFormatsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCoreTransformerInputFormatsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCoreTransformerInputFormatsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCoreTransformerInputFormatsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCoreTransformerInputFormatsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCoreTransformerInputFormatsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCoreTransformerInputFormatsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCoreTransformerInputFormatsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerParam(TypedDict, total=False):
+    field: Required[builtins.str]
+    type: Required[Literal['string', 'number', 'integer', 'boolean']]
+    value_source: Required[Literal['inline', 'range', 'enumerable', 'free_text']]
+    max_length: NotRequired[builtins.int]
+    allowed_values: NotRequired[builtins.list[Any]]
+    minimum: NotRequired[builtins.float]
+    maximum: NotRequired[builtins.float]
+    options: NotRequired[builtins.list[_ExternalCoreTransformerParamOptionsItem]]
+    options_cursor: NotRequired[builtins.str]
+    default: NotRequired[Any]
+    required: NotRequired[builtins.bool]
+    description: NotRequired[builtins.str]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreTransformerPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerMultiplicity(TypedDict, total=False):
+    supports_catalog_fanout: NotRequired[builtins.bool]
+    max_creatives_limit: NotRequired[builtins.int]
+    supports_variants: NotRequired[builtins.bool]
+    max_variants_limit: NotRequired[builtins.int]
+    variant_dimensions: NotRequired[builtins.list[Literal['voice', 'theme', 'best_of_n', 'transformer_config', 'custom']]]
+
+class _ExternalCoreUserMatch(TypedDict, total=False):
+    uids: NotRequired[builtins.list[_ExternalCoreUserMatchUidsItem]]
+    hashed_email: NotRequired[builtins.str]
+    hashed_phone: NotRequired[builtins.str]
+    click_id: NotRequired[builtins.str]
+    click_id_type: NotRequired[builtins.str]
+    client_ip: NotRequired[builtins.str]
+    client_user_agent: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreEventCustomData(TypedDict, total=False):
+    value: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    order_id: NotRequired[builtins.str]
+    content_ids: NotRequired[builtins.list[builtins.str]]
+    content_type: NotRequired[builtins.str]
+    content_name: NotRequired[builtins.str]
+    content_category: NotRequired[builtins.str]
+    num_items: NotRequired[builtins.int]
+    search_string: NotRequired[builtins.str]
+    progress_percent: NotRequired[builtins.float]
+    progress_seconds: NotRequired[builtins.float]
+    contents: NotRequired[builtins.list[_ExternalCoreEventCustomDataContentsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreEventSurface(TypedDict, total=False):
+    category: Required[Literal['owned_property', 'website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    property_type: NotRequired[builtins.str]
+    namespace: NotRequired[builtins.str]
+    property_id: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PackageRequestBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _PackageRequestBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_PackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _PackageRequestOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _PackageRequestOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreAudienceEvidenceRequirementsMaximumAge(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days']]
+
+class _ExternalCoreAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant3(TypedDict, total=False):
+    type: Required[Literal['origin']]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _ExternalCoreMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _PackageRequestCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCorePlacementRef(TypedDict, total=False):
+    publisher_domain: NotRequired[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _PackageRequestCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PackageRequestCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PackageRequestCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PackageRequestCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PackageRequestCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PackageRequestCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant1 | _PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant1 | _PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeRequestRequestsItemInputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1Response(TypedDict, total=False):
+    previews: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2Response(TypedDict, total=False):
+    previews: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItem]]
+    interactive_url: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant1Embedding]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant2Embedding]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponsePreviewsItem2RendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeResponseManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeResponseManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeResponseManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ProvidePerformanceFeedbackRequestMetricVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ProvidePerformanceFeedbackRequestEvidenceConfidenceInterval(TypedDict, total=False):
+    lower: Required[builtins.float]
+    upper: Required[builtins.float]
+    level: Required[builtins.float]
+
+class _TargetingKvs2Item(TypedDict, total=False):
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _RefineProposalsRequestPushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _RefineProposalsRequestRefinementsItemVariant1Constraints(TypedDict, total=False):
+    total_budget: NotRequired[_ExternalMediaBuyProposalBudgetConstraint]
+    cpm: NotRequired[_RefineProposalsRequestRefinementsItemVariant1ConstraintsCpm]
+    impressions: NotRequired[_RefineProposalsRequestRefinementsItemVariant1ConstraintsImpressions]
+    flight: NotRequired[_RefineProposalsRequestRefinementsItemVariant1ConstraintsFlight]
+
+class _RefineProposalsRequestRefinementsItemVariant1Alternatives(TypedDict, total=False):
+    count: Required[builtins.int]
+
+class _RefineProposalsRequestRefinementsItemVariant2Constraints(TypedDict, total=False):
+    total_budget: NotRequired[_ExternalMediaBuyProposalBudgetConstraint]
+    cpm: NotRequired[_RefineProposalsRequestRefinementsItemVariant2ConstraintsCpm]
+    impressions: NotRequired[_RefineProposalsRequestRefinementsItemVariant2ConstraintsImpressions]
+    flight: NotRequired[_RefineProposalsRequestRefinementsItemVariant2ConstraintsFlight]
+
+class _RefineProposalsRequestRefinementsItemVariant2Alternatives(TypedDict, total=False):
+    count: Required[builtins.int]
+
+class _RefineProposalsResponseResultsItemVariant3Proposal(TypedDict, total=False):
+    proposal_id: Required[builtins.str]
+    proposal_kind: Required[Literal['new_media_buy', 'media_buy_update', 'media_buy_cancellation']]
+    parent_proposal_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    opportunity_id: NotRequired[builtins.str]
+    base_media_buy_revision: NotRequired[builtins.int]
+    proposal_status: Required[Literal['committed']]
+    accepted_at: NotRequired[builtins.str]
+    expires_at: Required[builtins.str]
+    name: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    brief_alignment: NotRequired[builtins.str]
+    commercial_terms: Required[_ExternalMediaBuyCommercialTerms]
+    terms_digest: Required[builtins.str]
+    insertion_order: NotRequired[_ExternalCoreInsertionOrder]
+
+class _ReportPlanOutcomeRequestSellerResponsePackagesItem(TypedDict, total=False):
+    budget: NotRequired[builtins.float]
+
+class _ReportPlanOutcomeRequestDeliveryReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ReportUsageRequestUsageItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ReportUsageRequestUsageItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _RequestProposalsRequestPushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _SearchBrandResultHouse(TypedDict, total=False):
+    domain: Required[builtins.str]
+    name: Required[builtins.str]
+
+class _SearchBrandResultLogosItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    orientation: NotRequired[Literal['square', 'horizontal', 'vertical', 'stacked']]
+    background: NotRequired[Literal['dark-bg', 'light-bg', 'transparent-bg']]
+    variant: NotRequired[Literal['primary', 'secondary', 'icon', 'wordmark', 'full-lockup']]
+
+class _SearchBrandResultRights(TypedDict, total=False):
+    available_uses: NotRequired[builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]]
+    countries: NotRequired[builtins.list[builtins.str]]
+    excluded_countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipal(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    account: NotRequired[_ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipalAccount]
+    operator: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligation(TypedDict, total=False):
+    required: Required[builtins.bool]
+    label_text: NotRequired[builtins.str]
+    timing: NotRequired[Literal['before_use', 'at_first_influenced_output', 'near_each_influenced_output']]
+    proximity: NotRequired[Literal['session_level', 'near_rendered_unit', 'near_influenced_output']]
+    jurisdictions: NotRequired[builtins.list[_ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligationJurisdictionsItem]]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['brand_agent', 'seller', 'network', 'platform']]
+
+class _ExternalSponsoredIntelligenceSiIdentityPrivacyPolicyAcknowledged(TypedDict, total=False):
+    brand_policy_url: NotRequired[builtins.str]
+    brand_policy_version: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentityUser(TypedDict, total=False):
+    email: NotRequired[builtins.str]
+    name: NotRequired[builtins.str]
+    locale: NotRequired[builtins.str]
+    phone: NotRequired[builtins.str]
+    shipping_address: NotRequired[_ExternalSponsoredIntelligenceSiIdentityUserShippingAddress]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalities(TypedDict, total=False):
+    conversational: NotRequired[builtins.bool]
+    voice: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVoiceVariant2]
+    video: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVideoVariant2]
+    avatar: NotRequired[builtins.bool | _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesAvatarVariant2]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesComponents(TypedDict, total=False):
+    standard: NotRequired[builtins.list[Literal['text', 'link', 'image', 'product_card', 'carousel', 'action_button']]]
+    extensions: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesCommerce(TypedDict, total=False):
+    acp_checkout: NotRequired[builtins.bool]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesA2ui(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    catalogs: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceipt(TypedDict, total=False):
+    status: Required[Literal['accepted', 'rejected']]
+    accepted_context_use: NotRequired[Literal['presentation_only', 'comparison_set', 'reasoning_context']]
+    received_at: Required[builtins.str]
+    host_surface: NotRequired[builtins.str]
+    disclosure_commitment: NotRequired[_ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceiptDisclosureCommitment]
+    rejection_reason: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiUiElement(TypedDict, total=False):
+    type: Required[Literal['text', 'link', 'image', 'product_card', 'carousel', 'action_button', 'app_handoff', 'integration_actions']]
+    data: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalA2uiSurface(TypedDict, total=False):
+    surfaceId: Required[builtins.str]
+    catalogId: NotRequired[builtins.str]
+    components: Required[builtins.list[_ExternalA2uiComponent]]
+    rootId: NotRequired[builtins.str]
+    dataModel: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SiSendMessageResponseHandoffIntent(TypedDict, total=False):
+    action: NotRequired[builtins.str]
+    product: NotRequired[builtins.dict[builtins.str, Any]]
+    price: NotRequired[_SiSendMessageResponseHandoffIntentPrice]
+
+class _SiSendMessageResponseHandoffContextForCheckout(TypedDict, total=False):
+    conversation_summary: NotRequired[builtins.str]
+    applied_offers: NotRequired[builtins.list[builtins.str]]
+
+class _SiTerminateSessionRequestTerminationContextTransactionIntent(TypedDict, total=False):
+    action: NotRequired[Literal['purchase', 'subscribe']]
+    product: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsRequestAccountsItemVariant1AccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant1AccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _ExternalCoreOperatorIdentity(TypedDict, total=False):
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+
+class _SyncAccountsRequestAccountsItemVariant1NotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['creative.status_changed', 'creative.assignment_changed', 'indicators.changed', 'creative.purged', 'account.status_changed', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    product_payload_view: NotRequired[Literal['canonical', 'legacy']]
+    authentication: NotRequired[_SyncAccountsRequestAccountsItemVariant1NotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsRequestAccountsItemVariant2AccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant2AccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncAccountsRequestAccountsItemVariant2NotificationConfigsItem(TypedDict, total=False):
+    subscriber_id: Required[builtins.str]
+    url: Required[builtins.str]
+    event_types: Required[builtins.list[Literal['creative.status_changed', 'creative.assignment_changed', 'indicators.changed', 'creative.purged', 'account.status_changed', 'product.created', 'product.updated', 'product.priced', 'product.removed', 'signal.created', 'signal.updated', 'signal.priced', 'signal.removed', 'wholesale_feed.bulk_change']]]
+    product_payload_view: NotRequired[Literal['canonical', 'legacy']]
+    authentication: NotRequired[_SyncAccountsRequestAccountsItemVariant2NotificationConfigsItemAuthentication]
+    active: NotRequired[builtins.bool]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAccountsResponseAccountsItemIdentityChangeVariant1(TypedDict, total=False):
+    status: Required[Literal['pending_approval']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    requested_at: NotRequired[builtins.str]
+
+class _SyncAccountsResponseAccountsItemIdentityChangeVariant2(TypedDict, total=False):
+    status: Required[Literal['rejected']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    requested_at: NotRequired[builtins.str]
+    reason: Required[builtins.str]
+
+class _SyncAccountsResponseAccountsItemIdentityChangePreviewVariant1(TypedDict, total=False):
+    outcome: Required[Literal['would_apply']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    impacts: Required[builtins.list[_NonblockingImpactsItem]]
+
+class _SyncAccountsResponseAccountsItemIdentityChangePreviewVariant2(TypedDict, total=False):
+    outcome: Required[Literal['would_require_approval']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    impacts: Required[builtins.list[_NonblockingImpactsItem]]
+
+class _SyncAccountsResponseAccountsItemIdentityChangePreviewVariant3(TypedDict, total=False):
+    outcome: Required[Literal['blocked']]
+    requested_operator_identity: Required[_ExternalCoreOperatorIdentity]
+    impacts: Required[builtins.list[_Impact]]
+    blockers: Required[builtins.list[builtins.str]]
+
+class _SyncAccountsResponseAccountsItemSetup(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    message: Required[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _SyncAccountsResponseAccountsItemCreditLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _SyncAgentNotificationConfigsRequestNotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _ExternalCoreAgentNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceMember(TypedDict, total=False):
+    external_id: Required[builtins.str]
+    hashed_email: NotRequired[builtins.str]
+    hashed_phone: NotRequired[builtins.str]
+    uids: NotRequired[builtins.list[_ExternalCoreAudienceMemberUidsItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _SyncAudiencesResponseAudiencesItemMatchBreakdownItem(TypedDict, total=False):
+    id_type: Required[Literal['hashed_email', 'hashed_phone', 'rampid', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'other']]
+    submitted: Required[builtins.int]
+    matched: Required[builtins.int]
+    match_rate: Required[builtins.float]
+
+class _SyncCatalogsResponseCatalogsItemItemIssuesItem(TypedDict, total=False):
+    item_id: Required[builtins.str]
+    status: Required[Literal['approved', 'pending', 'rejected', 'warning', 'withdrawn']]
+    reasons: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreCatalogItemAvailabilityError(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+    field: NotRequired[builtins.str]
+    suggestion: NotRequired[builtins.str]
+    retry_after: NotRequired[builtins.float]
+    issues: NotRequired[builtins.list[_ExternalCoreCatalogItemAvailabilityErrorIssuesItem]]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    recovery: NotRequired[Literal['transient', 'correctable', 'terminal']]
+    source: NotRequired[Literal['producer', 'sdk']]
+    sdk_id: NotRequired[builtins.str]
+
+class _SyncCatalogsResponseErrorsItemIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_SyncCatalogsResponseErrorsItemIssuesItemDiscriminatorItem]]
+
+class _SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _SyncCreativesRequestCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _SyncCreativesRequestCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalCoreCreativeLocalization(TypedDict, total=False):
+    source: Required[_ExternalCoreCreativeLocalizationSource]
+    target_variants: Required[builtins.list[_ExternalCoreCreativeLocalizationTargetVariantsItem]]
+    locale_fallbacks: NotRequired[builtins.list[_ExternalCoreCreativeLocalizationLocaleFallbacksItem]]
+    default_locale_variant_id: Required[builtins.str]
+    unmatched_locale_action: Required[Literal['serve_default', 'do_not_serve']]
+
+class _SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _SyncCreativesRequestCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _SyncCreativesRequestCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _SyncEventSourcesResponseEventSourcesItemSetup(TypedDict, total=False):
+    snippet: NotRequired[builtins.str]
+    snippet_type: NotRequired[Literal['javascript', 'html', 'pixel_url', 'server_only']]
+    instructions: NotRequired[builtins.str]
+
+class _ExternalCoreEventSourceHealth(TypedDict, total=False):
+    status: Required[Literal['insufficient', 'minimum', 'good', 'excellent']]
+    detail: NotRequired[_ExternalCoreEventSourceHealthDetail]
+    match_rate: NotRequired[builtins.float]
+    last_event_at: NotRequired[builtins.str]
+    evaluated_at: NotRequired[builtins.str]
+    events_received_24h: NotRequired[builtins.int]
+    issues: NotRequired[builtins.list[_ExternalCoreDiagnosticIssue]]
+
+class _SyncGovernanceRequestAccountsItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncGovernanceRequestAccountsItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncGovernanceRequestAccountsItemGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    authentication: Required[_SyncGovernanceRequestAccountsItemGovernanceAgentsItemAuthentication]
+
+class _SyncGovernanceResponseAccountsItemAccountVariant1(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _SyncGovernanceResponseAccountsItemAccountVariant2(TypedDict, total=False):
+    brand: Required[_ExternalCoreBrandRef]
+    operator: Required[builtins.str]
+    operator_unit: NotRequired[_ExternalCoreOperatorUnit]
+    currency: NotRequired[builtins.str]
+    timezone: NotRequired[builtins.str]
+    sandbox: NotRequired[builtins.bool]
+
+class _SyncGovernanceResponseAccountsItemGovernanceAgentsItem(TypedDict, total=False):
+    url: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemBudgetVariant1(TypedDict, total=False):
+    total: Required[builtins.float]
+    currency: Required[builtins.str]
+    accounting_mode: NotRequired[Literal['gross_commitment', 'verified_net_cost']]
+    per_seller_max_pct: NotRequired[builtins.float]
+    reallocation_threshold: Required[builtins.float]
+    reallocation_unlimited: NotRequired[builtins.bool]
+    allocations: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemBudgetVariant1AllocationsValue]]
+
+class _SyncPlansRequestPlansItemBudgetVariant2(TypedDict, total=False):
+    total: Required[builtins.float]
+    currency: Required[builtins.str]
+    accounting_mode: NotRequired[Literal['gross_commitment', 'verified_net_cost']]
+    per_seller_max_pct: NotRequired[builtins.float]
+    reallocation_threshold: NotRequired[builtins.float]
+    reallocation_unlimited: Required[Literal[True]]
+    allocations: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemBudgetVariant2AllocationsValue]]
+
+class _SyncPlansRequestPlansItemChannels(TypedDict, total=False):
+    required: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    allowed: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    mix_targets: NotRequired[builtins.dict[builtins.str, _SyncPlansRequestPlansItemChannelsMixTargetsValue]]
+
+class _SyncPlansRequestPlansItemFlight(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraints(TypedDict, total=False):
+    include: NotRequired[builtins.list[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant4]]
+    exclude: NotRequired[builtins.list[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant4]]
+
+class _SyncPlansRequestPlansItemDelegationsItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    authority: Required[Literal['full', 'execute_only', 'propose_only']]
+    budget_limit: NotRequired[_SyncPlansRequestPlansItemDelegationsItemBudgetLimit]
+    markets: NotRequired[builtins.list[builtins.str]]
+    expires_at: NotRequired[builtins.str]
+
+class _SyncPlansRequestPlansItemPortfolio(TypedDict, total=False):
+    member_plan_ids: Required[builtins.list[builtins.str]]
+    total_budget_cap: NotRequired[_SyncPlansRequestPlansItemPortfolioTotalBudgetCap]
+    shared_policy_ids: NotRequired[builtins.list[builtins.str]]
+    shared_exclusions: NotRequired[builtins.list[_ExternalGovernancePolicyEntry]]
+
+class _SyncPlansResponsePlansItemCategoriesItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    status: Required[Literal['active', 'inactive']]
+
+class _SyncPlansResponsePlansItemResolvedPoliciesItem(TypedDict, total=False):
+    policy_id: Required[builtins.str]
+    source: Required[Literal['explicit', 'auto_applied']]
+    enforcement: Required[Literal['must', 'should', 'may']]
+    reason: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksGetRequestAccountVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverride]
+
+class _TasksGetRequestAccountVariant2OperatorUnit(TypedDict, total=False):
+    id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+
+class _TasksGetResponseAdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksGetResponseAdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksGetResponsePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksGetResponseErrorDetails(TypedDict, total=False):
+    protocol: NotRequired[Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']]
+    operation: NotRequired[builtins.str]
+    specific_context: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestAccountVariant2Brand(TypedDict, total=False):
+    domain: Required[builtins.str]
+    brand_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    industries: NotRequired[builtins.list[builtins.str]]
+    data_subject_contestation: NotRequired[_TasksListRequestAccountVariant2BrandDataSubjectContestation]
+    brand_kit_override: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverride]
+
+class _TasksListRequestAccountVariant2OperatorUnit(TypedDict, total=False):
+    id: Required[builtins.str]
+    name: NotRequired[builtins.str]
+
+class _TasksListResponseAdcpErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_TasksListResponseAdcpErrorIssuesItemDiscriminatorItem]]
+
+class _TasksListResponsePushNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _TasksListResponseQuerySummaryDomainBreakdown(TypedDict, total=False):
+    signals: NotRequired[builtins.int]
+    creative: NotRequired[builtins.int]
+
+class _TasksListResponseQuerySummarySortApplied(TypedDict, total=False):
+    field: Required[builtins.str]
+    direction: Required[Literal['asc', 'desc']]
+
+class _UpdateCollectionListRequestBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant1(TypedDict, total=False):
+    type: Required[Literal['url']]
+    value: Required[builtins.str]
+    language: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2(TypedDict, total=False):
+    property_rid: Required[builtins.str]
+    artifact_id: Required[builtins.str]
+    variant_id: NotRequired[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    url: NotRequired[builtins.str]
+    published_time: NotRequired[builtins.str]
+    last_update_time: NotRequired[builtins.str]
+    assets: Required[builtins.list[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4]]
+    metadata: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    identifiers: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant2 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant1 | _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyPackageUpdateKeywordTargetsAddItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+    bid_price: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateKeywordTargetsRemoveItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateNegativeKeywordsAddItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateNegativeKeywordsRemoveItem(TypedDict, total=False):
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant1 | _ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateCreativesItemVariant1InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2(TypedDict, total=False):
+    creative_id: Required[builtins.str]
+    name: Required[builtins.str]
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant1 | _ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    inputs: NotRequired[builtins.list[_ExternalMediaBuyPackageUpdateCreativesItemVariant2InputsItem]]
+    tags: NotRequired[builtins.list[builtins.str]]
+    status: NotRequired[Literal['processing', 'pending_review', 'approved', 'suspended', 'rejected', 'archived']]
+    weight: NotRequired[builtins.float]
+    placement_refs: NotRequired[builtins.list[_ExternalCorePlacementRef]]
+    placement_ids: NotRequired[builtins.list[builtins.str]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _UpdateMediaBuyResponseBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _UpdateMediaBuyResponseBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _UpdateRightsResponseRightsConstraintRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _UpdateRightsResponseRightsConstraintDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    text: NotRequired[builtins.str]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItem(TypedDict, total=False):
+    issuer: Required[_UpdateRightsResponseRightsConstraintAttestationRefsItemIssuerVariant1 | _UpdateRightsResponseRightsConstraintAttestationRefsItemIssuerVariant2 | _UpdateRightsResponseRightsConstraintAttestationRefsItemIssuerVariant3]
+    claim_type: Required[Literal['https://adcontextprotocol.org/claims/rights/grant']]
+    subject: Required[_UpdateRightsResponseRightsConstraintAttestationRefsItemSubjectVariant1 | _UpdateRightsResponseRightsConstraintAttestationRefsItemSubjectVariant2 | _UpdateRightsResponseRightsConstraintAttestationRefsItemSubjectVariant3]
+    locator: NotRequired[_UpdateRightsResponseRightsConstraintAttestationRefsItemLocatorVariant1 | _UpdateRightsResponseRightsConstraintAttestationRefsItemLocatorVariant2]
+    embedded_credential: NotRequired[_UpdateRightsResponseRightsConstraintAttestationRefsItemEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_UpdateRightsResponseRightsConstraintAttestationRefsItemValidityHint]
+    verify_agent: NotRequired[_UpdateRightsResponseRightsConstraintAttestationRefsItemVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ValidateContentDeliveryRequestRecordsItemBrandContext(TypedDict, total=False):
+    brand_id: NotRequired[builtins.str]
+    sku_id: NotRequired[builtins.str]
+
+class _ValidateContentDeliveryResponseResultsItemFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    confidence: NotRequired[builtins.float]
+
+class _ValidateInputRequestManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ValidateInputRequestManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ValidateInputRequestManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ValidateInputRequestManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCreativeValidateInputResultTarget(TypedDict, total=False):
+    kind: Required[Literal['canonical', 'product', 'third_party_format', 'capability']]
+    id: Required[builtins.str]
+
+class _ExternalCreativeValidateInputResultViolationsItem(TypedDict, total=False):
+    rule: Required[builtins.str]
+    expected: NotRequired[Any]
+    predicted: NotRequired[Any]
+    field: Required[builtins.str]
+    retry_with: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPropertyValidationResultFeaturesItem(TypedDict, total=False):
+    feature_id: Required[builtins.str]
+    status: Required[Literal['passed', 'failed', 'warning', 'unevaluated']]
+    policy_id: NotRequired[builtins.str]
+    explanation: NotRequired[builtins.str]
+    requirement: NotRequired[_ExternalPropertyValidationResultFeaturesItemRequirement]
+    confidence: NotRequired[builtins.float]
+
+class _ExternalPropertyAuthorizationResult(TypedDict, total=False):
+    status: Required[Literal['authorized', 'unauthorized', 'unknown']]
+    publisher_domain: NotRequired[builtins.str]
+    sales_agent_url: NotRequired[builtins.str]
+    violation: NotRequired[_ExternalPropertyAuthorizationResultViolation]
+
+class _VerifyBrandClaimRequestClaim3Property(TypedDict, total=False):
+    type: Required[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]
+    identifier: Required[builtins.str]
+    store: NotRequired[Literal['apple', 'google', 'amazon', 'roku', 'fire_tv', 'samsung', 'lg', 'vizio', 'other']]
+    region: NotRequired[builtins.str]
+
+class _SignedResponsePayload(TypedDict, total=False):
+    typ: Required[Literal['adcp-response-payload+jws']]
+    task: Required[Literal['verify_brand_claim']]
+    brand_domain: Required[builtins.str]
+    agent_url: Required[builtins.str]
+    request_hash: Required[builtins.str]
+    iat: Required[builtins.int]
+    exp: Required[builtins.int]
+    response: Required[_SignedResponsePayloadResponse]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant1Claim(TypedDict, total=False):
+    subsidiary_domain: Required[builtins.str]
+    subsidiary_brand_id: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant2Claim(TypedDict, total=False):
+    parent_domain: Required[builtins.str]
+    claimant_says: NotRequired[builtins.str]
+    observed_at: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant3Claim(TypedDict, total=False):
+    property: Required[_VerifyBrandClaimsRequestClaimsItemVariant3ClaimProperty]
+    use_case: NotRequired[builtins.str]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant4Claim(TypedDict, total=False):
+    mark: Required[builtins.str]
+    registry: NotRequired[builtins.str]
+    number: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    use_case: NotRequired[builtins.str]
+
+class _SignedResponse2Payload(TypedDict, total=False):
+    typ: Required[Literal['adcp-response-payload+jws']]
+    task: Required[Literal['verify_brand_claims']]
+    brand_domain: Required[builtins.str]
+    agent_url: Required[builtins.str]
+    request_hash: Required[builtins.str]
+    iat: Required[builtins.int]
+    exp: Required[builtins.int]
+    response: Required[_SignedResponse2PayloadResponse]
+
+class _ExternalCoreErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItem(TypedDict, total=False):
+    product_id: Required[builtins.str]
+    pricing_option_id: Required[builtins.str]
+    pricing: Required[_ExternalCoreCanonicalPricingOption]
+    format_option_refs: NotRequired[builtins.list[_ExternalMediaBuyCommercialTermsPurchasesItemFormatOptionRefsItemVariant1 | _ExternalMediaBuyCommercialTermsPurchasesItemFormatOptionRefsItemVariant2]]
+    catalog_ids: NotRequired[builtins.list[builtins.str]]
+    budget: NotRequired[builtins.float]
+    daily_budget_cap: NotRequired[builtins.float]
+    min_spend_target: NotRequired[builtins.float]
+    impressions: NotRequired[builtins.float]
+    start_time: Required[builtins.str]
+    end_time: Required[builtins.str]
+    pacing: NotRequired[Literal['even', 'asap', 'front_loaded']]
+    bidding: NotRequired[_ExternalCoreBiddingPolicy]
+    targeting_overlay: NotRequired[_ExternalCoreTargeting]
+    optimization_goals: NotRequired[builtins.list[_ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant1 | _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant2 | _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant3]]
+    audience_evidence_requirements: NotRequired[_ExternalCoreProductAudienceEvidenceRequirements]
+    audience_evidence_pins: NotRequired[builtins.list[_ExternalCoreAudienceEvidencePin]]
+    agency_estimate_number: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    measurement_terms: NotRequired[_ExternalCoreCanonicalMeasurementTerms]
+    performance_standards: NotRequired[builtins.list[_ExternalCoreCanonicalPerformanceStandard]]
+
+class _ExternalMediaBuyCommercialTermsTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant1(TypedDict, total=False):
+    mode: Required[Literal['fixed']]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2(TypedDict, total=False):
+    mode: Required[Literal['seller_optimized']]
+    optimization_goals: Required[builtins.list[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant1 | _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant2 | _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant3]]
+
+class _ExternalMediaBuyCommercialTermsReportingCommitmentsItem(TypedDict, total=False):
+    purchase_index: Required[builtins.int]
+    metrics: Required[builtins.list[_ExternalMediaBuyCommercialTermsReportingCommitmentsItemMetricsItemVariant1 | _ExternalMediaBuyCommercialTermsReportingCommitmentsItemMetricsItemVariant2]]
+
+class _ExternalMediaBuyCommercialTermsCancellationTerms(TypedDict, total=False):
+    effective_at: Required[builtins.str]
+    fee: NotRequired[_ExternalMediaBuyCommercialTermsCancellationTermsFee]
+    reason: NotRequired[builtins.str]
+
+class _ExternalCoreInsertionOrderTerms(TypedDict, total=False):
+    advertiser: NotRequired[builtins.str]
+    publisher: NotRequired[builtins.str]
+    total_budget: NotRequired[_ExternalCoreInsertionOrderTermsTotalBudget]
+    flight_start: NotRequired[builtins.str]
+    flight_end: NotRequired[builtins.str]
+    payment_terms: NotRequired[Literal['net_30', 'net_60', 'net_90', 'prepaid', 'due_on_receipt']]
+
+class _ExternalCoreAssetsImageAsset(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    pixel_ratio: NotRequired[builtins.float]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalCoreBrandRefBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemIssuerVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemIssuerVariant3(TypedDict, total=False):
+    type: Required[Never]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemSubjectVariant1(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemSubjectVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemSubjectVariant3(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _AcquireRightsResponseRightsConstraintAttestationRefsItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _ExternalCoreRightsConstraintRightsAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreRightsConstraintDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    text: NotRequired[builtins.str]
+
+class _ExternalCoreRightsConstraintAttestationRefsItem(TypedDict, total=False):
+    issuer: Required[_ExternalCoreRightsConstraintAttestationRefsItemIssuerVariant1 | _ExternalCoreRightsConstraintAttestationRefsItemIssuerVariant2 | _ExternalCoreRightsConstraintAttestationRefsItemIssuerVariant3]
+    claim_type: Required[Literal['https://adcontextprotocol.org/claims/rights/grant']]
+    subject: Required[_ExternalCoreRightsConstraintAttestationRefsItemSubjectVariant1 | _ExternalCoreRightsConstraintAttestationRefsItemSubjectVariant2 | _ExternalCoreRightsConstraintAttestationRefsItemSubjectVariant3]
+    locator: NotRequired[_ExternalCoreRightsConstraintAttestationRefsItemLocatorVariant1 | _ExternalCoreRightsConstraintAttestationRefsItemLocatorVariant2]
+    embedded_credential: NotRequired[_ExternalCoreRightsConstraintAttestationRefsItemEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_ExternalCoreRightsConstraintAttestationRefsItemValidityHint]
+    verify_agent: NotRequired[_ExternalCoreRightsConstraintAttestationRefsItemVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _ExternalCoreProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _ExternalCoreProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_ExternalCoreProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_ExternalCoreProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_ExternalCoreProvenanceDisclosureJurisdictionsItem]]
+
+class _ExternalCoreProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Embedding]
+
+class _BuildCreativeResponsePreviewPreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Embedding]
+
+class _BuildCreativeResponsePreview2PreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemSignalConditionVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant1 | _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant1 | _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BuildCreativeResponseCreativesItemVariantsItemEval(TypedDict, total=False):
+    features: NotRequired[builtins.list[_ExternalCreativeCreativeFeatureResult]]
+    ranked_against: NotRequired[builtins.int]
+    calls_used: NotRequired[builtins.int]
+    seconds_used: NotRequired[builtins.float]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalPricingOptionsPriceGuidance(TypedDict, total=False):
+    p25: NotRequired[builtins.float]
+    p50: NotRequired[builtins.float]
+    p75: NotRequired[builtins.float]
+    p90: NotRequired[builtins.float]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreDuration]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant1Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant2Target(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyProductPurchaseOptimizationGoalsItemVariant3Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreProductAudienceEvidenceRequirementsMaximumAge(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days']]
+
+class _ExternalCoreProductAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandKey]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductAudienceEvidenceRequirementsAcceptedAttestationIssuersItemVariant3(TypedDict, total=False):
+    type: Required[Literal['origin']]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCanonicalMeasurementTermsBillingMeasurement(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandKey]
+    max_variance_percent: NotRequired[builtins.float]
+    measurement_window: NotRequired[builtins.str]
+    finalization_deadline_hours: NotRequired[builtins.int]
+
+class _ExternalCoreCanonicalMeasurementTermsMakegoodPolicy(TypedDict, total=False):
+    available_remedies: Required[builtins.list[Literal['additional_delivery', 'credit', 'invoice_adjustment']]]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreDuration]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2Target(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _BuyProductsRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalContentStandardsArtifactAssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _ExternalCoreFrequencyCapSuppress(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreFrequencyCapWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryAudienceTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCorePlannedDeliveryBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _ExternalCorePlannedDeliveryBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _ComplyTestControllerRequestParamsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCreativeAuditObservationDetailsClaimedValue(TypedDict, total=False):
+    human_oversight: Required[Literal['edited', 'directed']]
+    disclosure_required: Required[Literal[False]]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalTrustedMatchOfferCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreDuration]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2Target(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ControlMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreDuration]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant1Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant2Target(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageControlOptimizationGoalsItemVariant3Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCollectionCollectionListBaseCollectionsItemVariant1IdentifiersItem(TypedDict, total=False):
+    type: Required[Literal['apple_podcast_id', 'spotify_collection_id', 'rss_url', 'podcast_guid', 'amazon_music_id', 'iheart_id', 'podcast_index_id', 'youtube_channel_id', 'youtube_channel_handle', 'youtube_channel_url', 'youtube_playlist_id', 'amazon_title_id', 'roku_channel_id', 'pluto_channel_id', 'tubi_id', 'peacock_id', 'tiktok_id', 'twitch_channel', 'imdb_id', 'gracenote_id', 'eidr_id', 'domain', 'substack_id']]
+    value: Required[builtins.str]
+
+class _Exemplar(TypedDict, total=False):
+    scenario: Required[builtins.str]
+    explanation: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2 | _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _ExternalMediaBuyPackageRequestBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageRequestCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageRequestCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalCoreNotificationConfigAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreAudienceEvidenceSelectionAttestationEvaluationsItem(TypedDict, total=False):
+    reference: Required[_ExternalCoreAttestationReference]
+    evaluation: Required[_ExternalCoreAudienceEvidenceSelectionAttestationEvaluationsItemEvaluation]
+
+class _ExternalCorePackageBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _ExternalCorePackageBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: Required[builtins.float]
+    amount: NotRequired[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _ExternalPricingOptionsPriceBreakdownAdjustmentsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['fee', 'discount', 'commission', 'settlement']]
+    name: Required[builtins.str]
+    rate: NotRequired[builtins.float]
+    amount: Required[builtins.float]
+    description: NotRequired[builtins.str]
+    beneficiary: NotRequired[builtins.str]
+
+class _ExternalCoreDemographicTargetingResolution(TypedDict, total=False):
+    requested: Required[_ExternalCoreDemographicTargetingIntent]
+    applied: Required[_ExternalCoreDemographicPredicate]
+    equivalent: Required[Literal[True]]
+    execution: Required[_ExternalCoreDemographicTargetingResolutionExecutionVariant1 | _ExternalCoreDemographicTargetingResolutionExecutionVariant2 | _ExternalCoreDemographicTargetingResolutionExecutionVariant3]
+    applied_bases: NotRequired[builtins.list[Literal['verified', 'declared', 'inferred']]]
+    applied_verification_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageCommittedMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCoreCreativeLocalePolicy(TypedDict, total=False):
+    accepted_language_ranges: Required[builtins.list[builtins.str]]
+
+class _ExternalCorePlatformExtensionRef(TypedDict, total=False):
+    uri: Required[builtins.str]
+    digest: Required[builtins.str]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalImageCarousel(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalImageCarouselSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    card_aspect_ratio: NotRequired[builtins.str]
+    min_cards: NotRequired[builtins.int]
+    max_cards: NotRequired[builtins.int]
+    allowed_card_media_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    allowed_card_asset_types: NotRequired[builtins.list[Literal['image', 'video']]]
+    card_image_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_file_size_kb: NotRequired[builtins.int]
+    card_video_max_duration_ms: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    card_headline_max_chars: NotRequired[builtins.int]
+    card_description_max_chars: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalVideoHosted(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalVideoHostedSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    min_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    video_codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'mp3', 'opus', 'pcm']]]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    max_file_size_mb: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    captions: NotRequired[Literal['required', 'recommended', 'not_required']]
+    om_sdk_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    primary_text_max_chars: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    companion_banner_widths: NotRequired[builtins.list[builtins.int]]
+    companion_banner_heights: NotRequired[builtins.list[builtins.int]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalFormatsCanonicalVideoVast(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalVideoVastSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    orientation: NotRequired[Literal['vertical', 'horizontal', 'square']]
+    aspect_ratio: NotRequired[builtins.str]
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2', '4.3']]
+    vpaid_enabled: NotRequired[builtins.bool]
+    vpaid_version: NotRequired[Literal['1.0', '2.0']]
+    simid_supported: NotRequired[builtins.bool]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    skippable_after_ms: NotRequired[builtins.int]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAudioHosted(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalAudioHostedSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    duration_ms_range: NotRequired[builtins.list[builtins.int | None]]
+    duration_ms_exact: NotRequired[builtins.int]
+    audio_codecs: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'opus', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+    companion_image_required: NotRequired[builtins.bool]
+    companion_image_aspect_ratio: NotRequired[builtins.str]
+    companion_image_max_file_size_kb: NotRequired[builtins.int]
+    brand_name_max_chars: NotRequired[builtins.int]
+
+class _ExternalFormatsCanonicalAudioDaast(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalAudioDaastSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    daast_version: NotRequired[Literal['1.0', '1.1']]
+    duration_ms_range: NotRequired[builtins.list[builtins.int]]
+    duration_ms_exact: NotRequired[builtins.int]
+    linear_required: NotRequired[builtins.bool]
+    max_wrapper_depth: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+    companion_image_required: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalSponsoredPlacement(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalSponsoredPlacementSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    supported_catalog_types: NotRequired[builtins.list[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    fanout_mode: NotRequired[Literal['per_item', 'multi_item_in_creative', 'single_item']]
+    required_catalog_fields: NotRequired[builtins.list[builtins.str]]
+    supported_id_types: NotRequired[builtins.list[Literal['asin', 'sku', 'gtin', 'offering_id', 'store_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'program_id', 'destination_id', 'app_id', 'job_id']]]
+    hero_asset_supported: NotRequired[builtins.bool]
+    item_production_model: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized']]
+
+class _ExternalFormatsCanonicalNativeInFeed(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalNativeInFeedSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    title_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    main_image_sizes: NotRequired[builtins.list[_ExternalFormatsCanonicalNativeInFeedMainImageSizesItem]]
+    icon_size: NotRequired[_ExternalFormatsCanonicalNativeInFeedIconSize]
+    max_image_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp']]]
+    ssl_required: NotRequired[builtins.bool]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalFormatsCanonicalResponsiveCreative(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalResponsiveCreativeSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    headlines_min: NotRequired[builtins.int]
+    headlines_max: NotRequired[builtins.int]
+    headline_max_chars: NotRequired[builtins.int]
+    long_headlines_min: NotRequired[builtins.int]
+    long_headlines_max: NotRequired[builtins.int]
+    long_headline_max_chars: NotRequired[builtins.int]
+    descriptions_min: NotRequired[builtins.int]
+    descriptions_max: NotRequired[builtins.int]
+    description_max_chars: NotRequired[builtins.int]
+    images_landscape_min: NotRequired[builtins.int]
+    images_landscape_max: NotRequired[builtins.int]
+    images_landscape_aspect_ratio: NotRequired[builtins.str]
+    images_square_min: NotRequired[builtins.int]
+    images_square_max: NotRequired[builtins.int]
+    images_vertical_min: NotRequired[builtins.int]
+    images_vertical_max: NotRequired[builtins.int]
+    videos_min: NotRequired[builtins.int]
+    videos_max: NotRequired[builtins.int]
+    video_min_duration_ms: NotRequired[builtins.int]
+    video_max_duration_ms: NotRequired[builtins.int]
+    logo_min: NotRequired[builtins.int]
+    logo_max: NotRequired[builtins.int]
+    logo_aspect_ratios: NotRequired[builtins.list[builtins.str]]
+    business_name_max_chars: NotRequired[builtins.int]
+    asset_image_max_file_size_kb: NotRequired[builtins.int]
+    supports_catalog_input: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAgentPlacement(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalFormatsCanonicalAgentPlacementSlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    output_modality: NotRequired[Literal['text', 'audio', 'card']]
+    max_mention_length_chars: NotRequired[builtins.int]
+    max_mention_duration_ms: NotRequired[builtins.int]
+    supports_offering_reference: NotRequired[builtins.bool]
+    supports_landing_page_url: NotRequired[builtins.bool]
+    tone_constraints: NotRequired[builtins.list[builtins.str]]
+    disclosure_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePackageFormatsPendingItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalPropertyPropertyListPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _GetAdcpCapabilitiesResponseAdcpCapabilityChangesNotificationsVariant1(TypedDict, total=False):
+    supported: Required[Literal[True]]
+    registration_task: Required[Literal['sync_agent_notification_configs']]
+    event_types: Required[builtins.list[Literal['capabilities.changed']]]
+    coalescence_window_seconds: NotRequired[builtins.int]
+
+class _GetAdcpCapabilitiesResponseAdcpCapabilityChangesNotificationsVariant2(TypedDict, total=False):
+    supported: Required[Literal[False]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant1(TypedDict, total=False):
+    task: Required[Literal['create_media_buy']]
+    modes: Required[builtins.list[Literal['signed_context', 'online_execution_check']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant2(TypedDict, total=False):
+    task: Required[Literal['update_media_buy']]
+    modes: Required[builtins.list[Literal['signed_context', 'online_execution_check']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant3(TypedDict, total=False):
+    task: Required[Literal['buy_products']]
+    modes: Required[builtins.list[Literal['signed_context', 'online_execution_check']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant4(TypedDict, total=False):
+    task: Required[Literal['accept_proposal']]
+    modes: Required[builtins.list[Literal['signed_context', 'online_execution_check']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant5(TypedDict, total=False):
+    task: Required[Literal['control_media_buy']]
+    modes: Required[builtins.list[Literal['signed_context', 'online_execution_check']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant6(TypedDict, total=False):
+    task: Required[Literal['build_creative']]
+    modes: Required[builtins.list[Literal['signed_context']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant7(TypedDict, total=False):
+    task: Required[Literal['activate_signal']]
+    modes: Required[builtins.list[Literal['signed_context']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant8(TypedDict, total=False):
+    task: Required[Literal['acquire_rights']]
+    modes: Required[builtins.list[Literal['signed_context']]]
+
+class _GetAdcpCapabilitiesResponseAdcpGovernanceEnforcementTasksItemVariant9(TypedDict, total=False):
+    task: Required[Literal['update_rights']]
+    modes: Required[builtins.list[Literal['signed_context']]]
+
+class _ExternalCoreAttestationCapabilitiesAcceptedIssuersItem(TypedDict, total=False):
+    issuer: Required[_ExternalCoreAttestationCapabilitiesAcceptedIssuersItemIssuerVariant1 | _ExternalCoreAttestationCapabilitiesAcceptedIssuersItemIssuerVariant2 | _ExternalCoreAttestationCapabilitiesAcceptedIssuersItemIssuerVariant3]
+    claim_types: NotRequired[builtins.list[builtins.str]]
+    proof_formats: NotRequired[builtins.list[builtins.str]]
+    credential_origins: NotRequired[builtins.list[builtins.str]]
+    resolvers: NotRequired[builtins.list[_ExternalCoreAttestationCapabilitiesAcceptedIssuersItemResolversItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationCapabilitiesAcceptedVerifiersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    claim_types: NotRequired[builtins.list[builtins.str]]
+    proof_formats: NotRequired[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyFeaturesBiddingPolicy(TypedDict, total=False):
+    media_buy: NotRequired[_ScopeCapability]
+    package: NotRequired[_ScopeCapability]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTrustedMatch(TypedDict, total=False):
+    surfaces: NotRequired[builtins.list[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionCreativeSpecs(TypedDict, total=False):
+    vast_versions: NotRequired[builtins.list[builtins.str]]
+    mraid_versions: NotRequired[builtins.list[builtins.str]]
+    vpaid: NotRequired[builtins.bool]
+    simid: NotRequired[builtins.bool]
+    vast_validation: NotRequired[Literal['structural', 'document', 'wrapper']]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargeting(TypedDict, total=False):
+    geo_countries: NotRequired[builtins.bool]
+    geo_regions: NotRequired[builtins.bool | _ExternalCoreGeoRegionSupport]
+    geo_regions_exclude: NotRequired[builtins.bool | _ExternalCoreGeoRegionSupport]
+    geo_metros: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoMetros]
+    geo_postal_areas: NotRequired[_ExternalCorePostalAreaSupport]
+    geo_places: NotRequired[builtins.dict[builtins.str, _ExternalCoreGeoPlaceSupport]]
+    age_restriction: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingAgeRestriction]
+    demographics: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingDemographics]
+    language: NotRequired[builtins.bool | _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingLanguageVariant2]
+    keyword_targets: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingKeywordTargets]
+    negative_keywords: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingNegativeKeywords]
+    placement_selection: NotRequired[builtins.bool]
+    property_list: NotRequired[builtins.bool]
+    property_list_exclude: NotRequired[builtins.bool]
+    collection_list: NotRequired[builtins.bool]
+    collection_list_exclude: NotRequired[builtins.bool]
+    geo_proximity: NotRequired[_GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoProximity]
+
+class _GetAdcpCapabilitiesResponseMediaBuyAudienceTargetingMatchingLatencyHours(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+
+class _GetAdcpCapabilitiesResponseMediaBuyConversionTrackingAttributionWindowsItem(TypedDict, total=False):
+    event_type: NotRequired[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    post_click: Required[builtins.list[_ExternalCoreDuration]]
+    post_view: NotRequired[builtins.list[_ExternalCoreDuration]]
+
+class _GetAdcpCapabilitiesResponseGovernanceRuntimeAttestationsSignalActivation(TypedDict, total=False):
+    requirement: Required[Literal['optional', 'required']]
+    claim_types: Required[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseGovernancePropertyFeaturesItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetAdcpCapabilitiesResponseGovernanceCreativeFeaturesItemRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _GetAdcpCapabilitiesResponseSponsoredIntelligenceEndpointTransportsItem(TypedDict, total=False):
+    type: Required[Literal['mcp', 'a2a']]
+    url: Required[builtins.str]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3 | _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _GetAdcpCapabilitiesResponseMeasurementMetricsItemAccreditationsItem(TypedDict, total=False):
+    accrediting_body: Required[builtins.str]
+    certification_id: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    evidence_url: NotRequired[builtins.str]
+
+class _FontRoleVariant2FilesItem(TypedDict, total=False):
+    url: Required[builtins.str]
+    weight: NotRequired[builtins.int]
+    weight_range: NotRequired[builtins.list[builtins.int]]
+    style: NotRequired[Literal['normal', 'italic', 'oblique']]
+
+class _ExternalCoreDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreCreativeVariantReachWindowPeriod]
+
+class _ExternalCoreCreativeVariantQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCreativeVariantDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCreativeVariantViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCreativeVariantByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeVariantManifestVariant1(TypedDict, total=False):
+    format_id: Required[_ExternalCoreFormatId]
+    format_kind: NotRequired[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant1 | _ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeVariantManifestVariant2(TypedDict, total=False):
+    format_id: NotRequired[_ExternalCoreFormatId]
+    format_kind: Required[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']]
+    format_option_ref: NotRequired[_ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant1 | _ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant2]
+    assets: Required[builtins.dict[builtins.str, Any]]
+    brand: NotRequired[_ExternalCoreBrandRef]
+    rights: NotRequired[builtins.list[_ExternalCoreRightsConstraint]]
+    industry_identifiers: NotRequired[builtins.list[_ExternalCoreIndustryIdentifier]]
+    provenance: NotRequired[_ExternalCoreProvenance]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeVariantGenerationContext(TypedDict, total=False):
+    context_type: NotRequired[builtins.str]
+    artifact: NotRequired[_ExternalCoreCreativeVariantGenerationContextArtifact]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDemographicAgeRange(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    include_unknown: Required[builtins.bool]
+
+class _GetMediaBuyDeliveryResponseAggregatedTotalsMetricAggregatesItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1Qualifier]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreCatalogItemDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsQuartileData | _ExternalCoreCatalogItemDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    content_id: Required[builtins.str]
+    content_id_type: NotRequired[Literal['sku', 'gtin', 'offering_id', 'job_id', 'hotel_id', 'flight_id', 'vehicle_id', 'listing_id', 'store_id', 'program_id', 'destination_id', 'app_id']]
+
+class _ExternalCoreCreativeDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreCreativeDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreCreativeDeliveryMetricsQuartileData | _ExternalCoreCreativeDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreCreativeDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreCreativeDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    creative_id: Required[builtins.str]
+    weight: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreKeywordDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreKeywordDeliveryMetricsQuartileData | _ExternalCoreKeywordDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreKeywordDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreKeywordDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    keyword: Required[builtins.str]
+    match_type: Required[Literal['broad', 'phrase', 'exact']]
+
+class _ExternalCoreGeoDeliveryMetrics(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetricsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_ExternalCoreGeoDeliveryMetricsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_ExternalCoreGeoDeliveryMetricsQuartileData | _ExternalCoreGeoDeliveryMetricsQuartileData2]
+    dooh_metrics: NotRequired[_ExternalCoreGeoDeliveryMetricsDoohMetrics]
+    viewability: NotRequired[_ExternalCoreGeoDeliveryMetricsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetricsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    demographic: Required[builtins.str]
+    demographic_system: Required[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    age: NotRequired[_ExternalCoreDemographicAgeRange]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItem(TypedDict, total=False):
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    placement_id: Required[builtins.str]
+    placement_name: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    spot_id: Required[builtins.str]
+    aired_at: Required[builtins.str]
+    network: NotRequired[builtins.str]
+    station: NotRequired[builtins.str]
+    daypart: NotRequired[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDailyBreakdownItem(TypedDict, total=False):
+    date: Required[builtins.str]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotals(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItem(TypedDict, total=False):
+    impressions: NotRequired[builtins.float]
+    spend: NotRequired[builtins.float]
+    clicks: NotRequired[builtins.float]
+    ctr: NotRequired[builtins.float]
+    views: NotRequired[builtins.float]
+    completed_views: NotRequired[builtins.float]
+    completion_rate: NotRequired[builtins.float | None]
+    conversions: NotRequired[builtins.float]
+    conversion_value: NotRequired[builtins.float]
+    commissionable_value: NotRequired[builtins.float]
+    roas: NotRequired[builtins.float]
+    cost_per_acquisition: NotRequired[builtins.float]
+    new_to_brand_rate: NotRequired[builtins.float]
+    leads: NotRequired[builtins.float]
+    incremental_sales_lift: NotRequired[builtins.float]
+    brand_lift: NotRequired[builtins.float]
+    foot_traffic: NotRequired[builtins.float]
+    conversion_lift: NotRequired[builtins.float]
+    brand_search_lift: NotRequired[builtins.float]
+    plays: NotRequired[builtins.float]
+    by_event_type: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByEventTypeItem]]
+    grps: NotRequired[builtins.float]
+    reach: NotRequired[builtins.float]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    reach_window: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindow]
+    frequency: NotRequired[builtins.float]
+    quartile_data: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData | _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData2]
+    dooh_metrics: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetrics]
+    viewability: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemViewability]
+    engagements: NotRequired[builtins.float]
+    follows: NotRequired[builtins.float]
+    saves: NotRequired[builtins.float]
+    profile_visits: NotRequired[builtins.float]
+    engagement_rate: NotRequired[builtins.float]
+    cost_per_click: NotRequired[builtins.float]
+    cost_per_completed_view: NotRequired[builtins.float]
+    cpm: NotRequired[builtins.float]
+    downloads: NotRequired[builtins.float]
+    units_sold: NotRequired[builtins.float]
+    new_to_brand_units: NotRequired[builtins.float]
+    by_action_source: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByActionSourceItem]]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreVendorMetricValue]]
+    package_id: Required[builtins.str]
+
+class _ExternalCoreImpairmentTransition(TypedDict, total=False):
+    to: Required[Literal['suspended', 'rejected', 'withdrawn', 'insufficient', 'depublished']]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _GetMediaBuysResponseMediaBuysItemBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemBidding(TypedDict, total=False):
+    automatic: NotRequired[Literal[True]]
+    bid_amount: NotRequired[builtins.float]
+    max_bid: NotRequired[builtins.float]
+    cost_per: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemBiddingCostPer]
+    roas: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemBiddingRoas]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2TargetVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2TargetVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant3TargetVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemCancellation(TypedDict, total=False):
+    canceled_at: Required[builtins.str]
+    canceled_by: Required[Literal['buyer', 'seller']]
+    reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemCreativeApprovalsItem(TypedDict, total=False):
+    indicators: NotRequired[builtins.list[_ExternalCoreIndicator]]
+    indicator_types_evaluated: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    indicators_as_of: NotRequired[builtins.str]
+    indicators_evaluated_scope: NotRequired[builtins.list[_ExternalCoreIndicatorScope]]
+    creative_id: Required[builtins.str]
+    approval_status: Required[Literal['pending_review', 'approved', 'partially_approved', 'rejected']]
+    rejection_reason: NotRequired[builtins.str]
+    approval_scopes: NotRequired[builtins.list[_ExternalCoreCreativeApprovalScope]]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant4]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant4]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant4]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant4]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant4]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant1 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant2 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant3 | _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant4]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemSnapshot(TypedDict, total=False):
+    as_of: Required[builtins.str]
+    staleness_seconds: Required[builtins.int]
+    impressions: Required[builtins.float]
+    spend: Required[builtins.float]
+    currency: NotRequired[builtins.str]
+    clicks: NotRequired[builtins.float]
+    pacing_index: NotRequired[builtins.float]
+    delivery_status: NotRequired[Literal['delivering', 'not_delivering', 'completed', 'budget_exhausted', 'flight_ended', 'goal_met']]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryStatuses(TypedDict, total=False):
+    approved: NotRequired[builtins.int]
+    denied: NotRequired[builtins.int]
+    conditions: NotRequired[builtins.int]
+    human_reviewed: NotRequired[builtins.int]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryEscalationsItem(TypedDict, total=False):
+    check_id: Required[builtins.str]
+    reason: Required[builtins.str]
+    resolution: NotRequired[builtins.str]
+    resolved_at: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryDriftMetrics(TypedDict, total=False):
+    escalation_rate: NotRequired[builtins.float]
+    escalation_rate_trend: NotRequired[Literal['increasing', 'stable', 'declining']]
+    auto_approval_rate: NotRequired[builtins.float]
+    human_override_rate: NotRequired[builtins.float]
+    mean_confidence: NotRequired[builtins.float]
+    thresholds: NotRequired[_GetPlanAuditLogsResponsePlansItemSummaryDriftMetricsThresholds]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemFindingsItem(TypedDict, total=False):
+    category_id: Required[builtins.str]
+    policy_id: NotRequired[builtins.str]
+    source_plan_id: NotRequired[builtins.str]
+    severity: Required[Literal['info', 'warning', 'critical']]
+    explanation: Required[builtins.str]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    confidence: NotRequired[builtins.float]
+    uncertainty_reason: NotRequired[builtins.str]
+    attestation_reference_digest: NotRequired[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryStatement(TypedDict, total=False):
+    statement_id: Required[builtins.str]
+    statement_digest: Required[builtins.str]
+    sequence: Required[builtins.int]
+    issued_at: Required[builtins.str]
+    seller_reference: Required[builtins.str]
+    cumulative_spend: Required[builtins.float]
+    currency: Required[builtins.str]
+    reporting_period: Required[_GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryStatementReportingPeriod]
+    canonical_payload: Required[_GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryStatementCanonicalPayload]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemAmount(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemDelivery(TypedDict, total=False):
+    observation_id: NotRequired[builtins.str]
+    source: NotRequired[Literal['seller_statement_copy', 'buyer_measurement']]
+    observed_at: NotRequired[builtins.str]
+    seller_statement_id: NotRequired[builtins.str]
+    seller_statement_digest: NotRequired[builtins.str]
+    reporting_period: NotRequired[_GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryReportingPeriod]
+    cumulative_spend: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+    period_closed: NotRequired[builtins.bool]
+    impressions: NotRequired[builtins.int]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemRuntimeAttestationsItem(TypedDict, total=False):
+    reference: Required[_ExternalCoreAttestationReference]
+    evaluation: Required[_ExternalCoreAttestationEvaluation]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemEvidence(TypedDict, total=False):
+    evidence_id: Required[builtins.str]
+    evidence_type: Required[Literal['decommitment_agreement', 'refund_settlement', 'credit_note', 'makegood_agreement']]
+    digest: Required[builtins.str]
+    issued_at: Required[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemGovernedActionsItemDeliveryReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image']]
+    params: Required[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1 | _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2 | _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3 | _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['html5']]
+    params: Required[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1 | _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2 | _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3 | _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['display_tag']]
+    params: Required[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1 | _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2 | _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3 | _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4]
+
+class _ExternalCorePlacementFormatOptionsItemVariant4(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['image_carousel']]
+    params: Required[_ExternalFormatsCanonicalImageCarousel]
+
+class _ExternalCorePlacementFormatOptionsItemVariant5(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_hosted']]
+    params: Required[_ExternalFormatsCanonicalVideoHosted]
+
+class _ExternalCorePlacementFormatOptionsItemVariant6(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['video_vast']]
+    params: Required[_ExternalFormatsCanonicalVideoVast]
+
+class _ExternalCorePlacementFormatOptionsItemVariant7(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_hosted']]
+    params: Required[_ExternalFormatsCanonicalAudioHosted]
+
+class _ExternalCorePlacementFormatOptionsItemVariant8(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['audio_daast']]
+    params: Required[_ExternalFormatsCanonicalAudioDaast]
+
+class _ExternalCorePlacementFormatOptionsItemVariant9(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['sponsored_placement']]
+    params: Required[_ExternalFormatsCanonicalSponsoredPlacement]
+
+class _ExternalCorePlacementFormatOptionsItemVariant10(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['native_in_feed']]
+    params: Required[_ExternalFormatsCanonicalNativeInFeed]
+
+class _ExternalCorePlacementFormatOptionsItemVariant11(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['responsive_creative']]
+    params: Required[_ExternalFormatsCanonicalResponsiveCreative]
+
+class _ExternalCorePlacementFormatOptionsItemVariant12(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['agent_placement']]
+    params: Required[_ExternalFormatsCanonicalAgentPlacement]
+
+class _ExternalCorePlacementFormatOptionsItemVariant13(TypedDict, total=False):
+    format_option_id: NotRequired[builtins.str]
+    publisher_domain: NotRequired[builtins.str]
+    display_name: NotRequired[builtins.str]
+    sample_render_url: NotRequired[builtins.str]
+    applies_to_channels: NotRequired[builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']]]
+    seller_preference: NotRequired[Literal['preferred', 'accepted', 'discouraged']]
+    locale_policy: NotRequired[_ExternalCoreCreativeLocalePolicy]
+    canonical_formats_only: NotRequired[builtins.bool]
+    experimental: NotRequired[builtins.bool]
+    format_shape: NotRequired[builtins.str]
+    v1_format_ref: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    format_schema: NotRequired[_ExternalCorePlatformExtensionRef]
+    format_kind: Required[Literal['custom']]
+    params: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductPricingOptionsItemVariant5Parameters(TypedDict, total=False):
+    view_threshold: Required[builtins.float | _ExternalCoreProductPricingOptionsItemVariant5ParametersViewThresholdVariant2]
+
+class _ExternalCoreProductPricingOptionsItemVariant6Parameters(TypedDict, total=False):
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+    demographic: Required[builtins.str]
+    min_points: NotRequired[builtins.float]
+
+class _ExternalCoreProductPricingOptionsItemVariant9Parameters(TypedDict, total=False):
+    type: Required[Literal['dooh']]
+    sov_percentage: NotRequired[builtins.float]
+    loop_duration_seconds: NotRequired[builtins.int]
+    min_plays_per_hour: NotRequired[builtins.int]
+    venue_package: NotRequired[builtins.str]
+    duration_hours: NotRequired[builtins.float]
+    daypart: NotRequired[builtins.str]
+    estimated_impressions: NotRequired[builtins.int]
+
+class _ExternalCoreProductPricingOptionsItemVariant10Parameters(TypedDict, total=False):
+    time_unit: Required[Literal['hour', 'day', 'week', 'month']]
+    min_duration: NotRequired[builtins.int]
+    max_duration: NotRequired[builtins.int]
+
+class _ExternalCoreForecastPoint(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_ExternalCoreForecastPointDimensionsItemVariant1 | _ExternalCoreForecastPointDimensionsItemVariant2 | _ExternalCoreForecastPointDimensionsItemVariant3 | _ExternalCoreForecastPointDimensionsItemVariant4 | _ExternalCoreForecastPointDimensionsItemVariant5 | _ExternalCoreForecastPointDimensionsItemVariant6]]
+    metrics: Required[_ExternalCoreForecastPointMetrics]
+    viewability: NotRequired[_ExternalCoreForecastPointViewability]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreForecastVendorMetricValue]]
+
+class _ExternalCoreOutcomeMeasurementWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCancellationPolicyCancellationFee(TypedDict, total=False):
+    type: Required[Literal['percent_remaining', 'full_commitment', 'fixed_fee', 'none']]
+    rate: NotRequired[builtins.float]
+    amount: NotRequired[builtins.float]
+
+class _ExternalCoreReportingCapabilitiesVendorMetricsItem(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreGeoBreakdownSupport(TypedDict, total=False):
+    country: NotRequired[builtins.bool]
+    region: NotRequired[builtins.bool]
+    metro: NotRequired[builtins.dict[builtins.str, builtins.bool]]
+    postal_area: NotRequired[_ExternalCorePostalAreaSupport]
+
+class _ExternalCoreDemographicReportingCapability(TypedDict, total=False):
+    age: NotRequired[_ExternalCoreDemographicReportingCapabilityAge]
+    demographic_systems: NotRequired[builtins.list[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]]
+    may_suppress_small_cells: Required[builtins.bool]
+
+class _ExternalCoreSpotReportingCapability(TypedDict, total=False):
+    available_metrics: Required[builtins.list[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]]
+
+class _ExternalCoreMeasurementWindow(TypedDict, total=False):
+    window_id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    duration_days: Required[builtins.int]
+    expected_availability_days: NotRequired[builtins.int]
+    is_guarantee_basis: NotRequired[builtins.bool]
+
+class _ExternalCoreCreativePolicyProvenanceRequirements(TypedDict, total=False):
+    require_digital_source_type: NotRequired[builtins.bool]
+    require_synthetic_depiction: NotRequired[builtins.bool]
+    require_disclosure_metadata: NotRequired[builtins.bool]
+    require_embedded_provenance: NotRequired[builtins.bool]
+
+class _ExternalCoreCreativePolicyAcceptedVerifiersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+    providers: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreSignalListingSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreSignalListingSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreSignalListingRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _ExternalCoreDemographicPredicate(TypedDict, total=False):
+    age: Required[_ExternalCoreDemographicAgeRange]
+
+class _ExternalCoreProductSignalTargetingOptionSignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionSignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductSignalTargetingOptionRange(TypedDict, total=False):
+    min: Required[builtins.float]
+    max: Required[builtins.float]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant1(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['cpm']]
+    cpm: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant2(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['percent_of_media']]
+    percent: Required[builtins.float]
+    max_cpm: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant3(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['flat_fee']]
+    amount: Required[builtins.float]
+    period: Required[Literal['monthly', 'quarterly', 'annual', 'campaign']]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant4(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['per_unit']]
+    unit: Required[builtins.str]
+    unit_price: Required[builtins.float]
+    currency: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5(TypedDict, total=False):
+    pricing_option_id: Required[builtins.str]
+    applies_to_output_format_ids: NotRequired[builtins.list[_ExternalCoreFormatId]]
+    applies_to_output_capability_ids: NotRequired[builtins.list[builtins.str]]
+    model: Required[Literal['custom']]
+    description: Required[builtins.str]
+    metadata: Required[_ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5Metadata]
+    currency: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreSignalSelectionGroupRule(TypedDict, total=False):
+    selection_group: Required[builtins.str]
+    targeting_mode: NotRequired[Literal['include', 'exclude']]
+    selection_mode: NotRequired[Literal['optional', 'required', 'fixed']]
+    min_selected_signals: NotRequired[builtins.int]
+    max_selected_signals: NotRequired[builtins.int]
+
+class _ExternalCoreDemographicTargetingCapabilityAge(TypedDict, total=False):
+    execution_modes: Required[builtins.list[Literal['continuous_bounds', 'enumerated_intervals', 'signals']]]
+    min_supported_age: NotRequired[builtins.int]
+    max_supported_age: NotRequired[builtins.int]
+    supports_unbounded_min: NotRequired[builtins.bool]
+    supports_unbounded_max: NotRequired[builtins.bool]
+    unknown_handling: Required[Literal['selectable', 'always_excluded', 'always_included']]
+    supported_bases: NotRequired[builtins.list[Literal['verified', 'declared', 'inferred']]]
+    supported_verification_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+    intervals: NotRequired[builtins.list[_ExternalCoreDemographicTargetingCapabilityAgeIntervalsItem]]
+
+class _ExternalCoreGeoRegionSupport(TypedDict, total=False):
+    countries: Required[builtins.dict[builtins.str, _ExternalCoreGeoRegionSupportCountriesValueVariant1 | _ExternalCoreGeoRegionSupportCountriesValueVariant2]]
+    catalog_version: NotRequired[builtins.str]
+    as_of: NotRequired[builtins.str]
+    max_values_per_package: NotRequired[builtins.int]
+    max_packages: NotRequired[builtins.int]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _MetroSupportVariant2(TypedDict, total=False):
+    systems: Required[builtins.list[Literal['nielsen_dma', 'uk_itl1', 'uk_itl2', 'eurostat_nuts2', 'custom']]]
+    max_values_per_package: NotRequired[builtins.int]
+    max_packages: NotRequired[builtins.int]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PlaceSupport(TypedDict, total=False):
+    systems: Required[builtins.dict[builtins.str, _PlaceCatalogSupport]]
+    max_values_per_package: NotRequired[builtins.int]
+    max_packages: NotRequired[builtins.int]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingOverlaySupportGeoProximityVariant2(TypedDict, total=False):
+    radius: NotRequired[Literal[True]]
+    travel_time: NotRequired[Literal[True]]
+    geometry: NotRequired[Literal[True]]
+    transport_modes: NotRequired[builtins.list[Literal['walking', 'cycling', 'driving', 'public_transport']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingOverlaySupportDemographicsVariant2(TypedDict, total=False):
+    age: Required[Literal[True]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTargetingOverlaySupportPlacementSelectionVariant2(TypedDict, total=False):
+    max_values_per_package: NotRequired[builtins.int]
+    max_packages: NotRequired[builtins.int]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _BrowserSupportVariant2(TypedDict, total=False):
+    families: Required[builtins.list[Literal['chrome', 'safari', 'firefox', 'edge', 'opera', 'samsung_internet', 'android_webview', 'other', 'unknown']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _KeywordSupportVariant2(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTargetingResolutionModificationsItemVariant1(TypedDict, total=False):
+    operation: Required[Literal['replace']]
+    path: Required[builtins.str]
+    applied: Required[Any]
+    reason: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTargetingResolutionModificationsItemVariant2(TypedDict, total=False):
+    operation: Required[Literal['remove_values']]
+    path: Required[Literal['/geo_countries', '/geo_countries_exclude', '/geo_regions', '/geo_regions_exclude', '/geo_postal_areas', '/geo_postal_areas_exclude', '/audience_include', '/audience_exclude', '/device_platform', '/device_platform_exclude', '/device_type', '/device_type_exclude', '/browser', '/browser_exclude', '/language']]
+    selector: NotRequired[_ExternalCoreProductTargetingResolutionModificationsItemVariant2Selector]
+    values: Required[builtins.list[builtins.str]]
+    reason: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceCharacteristic(TypedDict, total=False):
+    dimension: Required[builtins.str]
+    value: NotRequired[builtins.str | builtins.float | builtins.bool | builtins.list[builtins.str | builtins.float | builtins.bool]]
+    range: NotRequired[_ExternalCoreAudienceCharacteristicRange]
+    taxonomy: NotRequired[_ExternalCoreAudienceCharacteristicTaxonomy]
+    label: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceEvidenceBaseline(TypedDict, total=False):
+    system: Required[builtins.str]
+    population_id: Required[builtins.str]
+    version: Required[builtins.str]
+    description: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItem(TypedDict, total=False):
+    issuer: Required[_ExternalCoreAudienceEvidenceAttestationRefsItemIssuerVariant1 | _ExternalCoreAudienceEvidenceAttestationRefsItemIssuerVariant2 | _ExternalCoreAudienceEvidenceAttestationRefsItemIssuerVariant3]
+    claim_type: Required[builtins.str]
+    subject: Required[_ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant1 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant2 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant3 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant4 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant5 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant6 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant7 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant8 | _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant9]
+    locator: NotRequired[_ExternalCoreAudienceEvidenceAttestationRefsItemLocatorVariant1 | _ExternalCoreAudienceEvidenceAttestationRefsItemLocatorVariant2]
+    embedded_credential: NotRequired[_ExternalCoreAudienceEvidenceAttestationRefsItemEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_ExternalCoreAudienceEvidenceAttestationRefsItemValidityHint]
+    verify_agent: NotRequired[_ExternalCoreAudienceEvidenceAttestationRefsItemVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreVendorMetricOptimizationSupportedMetric(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    supported_targets: NotRequired[builtins.list[Literal['cost_per', 'threshold_rate']]]
+
+class _ExternalCoreDiagnosticIssue(TypedDict, total=False):
+    severity: Required[Literal['error', 'warning', 'info']]
+    message: Required[builtins.str]
+
+class _ExternalCoreProductProductCardDetailedSpecificationsItem(TypedDict, total=False):
+    label: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCoreProductCardReferenceAsset(TypedDict, total=False):
+    role: Required[Literal['coverage_map', 'sample_render', 'environment_photo', 'media_kit', 'logo', 'other']]
+    role_label: NotRequired[builtins.str]
+    asset: Required[_ExternalCoreProductCardReferenceAssetAssetVariant1 | _ExternalCoreProductCardReferenceAssetAssetVariant2 | _ExternalCoreProductCardReferenceAssetAssetVariant3 | _ExternalCoreProductCardReferenceAssetAssetVariant4]
+    description: NotRequired[builtins.str]
+
+class _ExternalCoreSpecial(TypedDict, total=False):
+    name: Required[builtins.str]
+    category: NotRequired[Literal['awards', 'championship', 'concert', 'conference', 'election', 'festival', 'gala', 'holiday', 'premiere', 'product_launch', 'reunion', 'tribute']]
+    starts: NotRequired[builtins.str]
+    ends: NotRequired[builtins.str]
+
+class _ExternalCoreTalent(TypedDict, total=False):
+    role: Required[Literal['host', 'guest', 'creator', 'cast', 'narrator', 'producer', 'correspondent', 'commentator', 'analyst']]
+    name: Required[builtins.str]
+    brand_url: NotRequired[builtins.str]
+
+class _ExternalCoreAdInventoryConfig(TypedDict, total=False):
+    expected_breaks: Required[builtins.int]
+    total_ad_seconds: NotRequired[builtins.int]
+    max_ad_duration_seconds: NotRequired[builtins.int]
+    unplanned_breaks: NotRequired[builtins.bool]
+    supported_formats: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreInstallmentDeadlines(TypedDict, total=False):
+    booking_deadline: NotRequired[builtins.str]
+    cancellation_deadline: NotRequired[builtins.str]
+    material_deadlines: NotRequired[builtins.list[_ExternalCoreMaterialDeadline]]
+
+class _ExternalCoreInstallmentDerivativeOf(TypedDict, total=False):
+    installment_id: Required[builtins.str]
+    type: Required[Literal['clip', 'highlight', 'recap', 'trailer', 'bonus']]
+
+class _ExternalCoreProductTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+    countries: NotRequired[builtins.list[builtins.str]]
+    uid_types: NotRequired[builtins.list[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]]
+
+class _ExternalCoreProductFiltersTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+
+class _ExternalCoreMediaBuyFeaturesBiddingPolicy(TypedDict, total=False):
+    media_buy: NotRequired[_ScopeCapability]
+    package: NotRequired[_ScopeCapability]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersSignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreProductFiltersGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCorePackageSignalTargetingGroup(TypedDict, total=False):
+    operator: Required[Literal['any', 'none']]
+    signals: Required[builtins.list[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3]]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTargetingSignalTargetingItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreDemographicTargetingIntentAge(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    include_unknown: Required[builtins.bool]
+    accepted_bases: NotRequired[builtins.list[Literal['verified', 'declared', 'inferred']]]
+    accepted_verification_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _ExternalCoreTargetingPlacementSelectionVariant1PlacementRefsItem(TypedDict, total=False):
+    publisher_domain: Required[builtins.str]
+    placement_id: Required[builtins.str]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant1Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant2Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3TravelTime(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['min', 'hr']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3Radius(TypedDict, total=False):
+    value: Required[builtins.float]
+    unit: Required[Literal['km', 'mi', 'm']]
+
+class _ExternalCoreTargetingGeoProximityItemVariant3Geometry(TypedDict, total=False):
+    type: Required[Literal['Polygon', 'MultiPolygon']]
+    coordinates: Required[builtins.list[Any]]
+
+class _ExternalCoreGeoRegionRequirementCountriesValueVariant1(TypedDict, total=False):
+    all_values: Required[Literal[True]]
+
+class _ExternalCoreGeoRegionRequirementCountriesValueVariant2(TypedDict, total=False):
+    values: Required[builtins.list[builtins.str]]
+
+class _CatalogRequirement(TypedDict, total=False):
+    countries: Required[builtins.dict[builtins.str, builtins.list[Literal['airport', 'borough', 'city', 'city_region', 'commune', 'county', 'district', 'municipality', 'neighborhood', 'post_town', 'prefecture', 'province', 'quarter', 'state', 'territory', 'ward'] | builtins.str]]]
+    system_versions: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'attention_seconds', 'attention_score', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1 | _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1 | _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2 | _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3]
+    attribution_window: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1 | _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2]
+    priority: NotRequired[builtins.int]
+
+class _GetSignalsResponseSignalsItemTaxonomyValuesItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    path: NotRequired[builtins.str]
+    modifiers: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsResponseSignalsItemTaxonomyValueMappingsItem(TypedDict, total=False):
+    value: Required[builtins.str]
+    taxonomy_value_id: Required[builtins.str]
+    path: NotRequired[builtins.str]
+    modifiers: NotRequired[builtins.list[builtins.str]]
+
+class _GetSignalsResponseSignalsItemModelingSeedSource(TypedDict, total=False):
+    type: Required[Literal['first_party_crm', 'panel', 'declared_survey', 'transactional', 'behavioral']]
+    provider_signed: Required[builtins.bool]
+
+class _ExternalCoreSignalModelingDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_ExternalCoreSignalModelingDisclosureJurisdictionsItem]]
+    notes: NotRequired[builtins.str]
+
+class _GetSignalsResponseSignalsItemDataSubjectRightsChannelsItem(TypedDict, total=False):
+    rights: Required[builtins.list[Literal['access', 'rectification', 'erasure', 'portability', 'objection']]]
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+    countries: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreSignalCoverageForecastPointsItem(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: Required[builtins.list[_ExternalCoreForecastPointDimensionsItemVariant1 | _ExternalCoreForecastPointDimensionsItemVariant2 | _ExternalCoreForecastPointDimensionsItemVariant3 | _ExternalCoreForecastPointDimensionsItemVariant4 | _ExternalCoreForecastPointDimensionsItemVariant5 | _ExternalCoreForecastPointDimensionsItemVariant6]]
+    metrics: Required[_ExternalCoreSignalCoverageForecastPointsItemMetrics]
+    viewability: NotRequired[_ExternalCoreSignalCoverageForecastPointsItemViewability]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreForecastVendorMetricValue]]
+
+class _ExternalCoreSignalCoverageForecastScope(TypedDict, total=False):
+    kind: Required[Literal['inventory', 'product', 'account', 'custom']]
+    label: Required[builtins.str]
+    product_id: NotRequired[builtins.str]
+    countries: NotRequired[builtins.list[builtins.str]]
+    line_item_types: NotRequired[builtins.list[builtins.str]]
+    date_range: NotRequired[_ExternalCoreDateRange]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemDeploymentsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _GetSignalsResponseSignalsItemPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalContentStandardsContentStandardsPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: NotRequired[builtins.float]
+    height: NotRequired[builtins.float]
+    min_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    responsive: NotRequired[_ExternalCoreFormatRendersItemVariant1DimensionsResponsive]
+    aspect_ratio: NotRequired[builtins.str]
+
+class _ExternalCoreFormatRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: NotRequired[builtins.float]
+    height: NotRequired[builtins.float]
+    min_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    responsive: NotRequired[_ExternalCoreFormatRendersItemVariant2DimensionsResponsive]
+    aspect_ratio: NotRequired[builtins.str]
+
+class _ExternalCoreOverlay(TypedDict, total=False):
+    id: Required[builtins.str]
+    description: NotRequired[builtins.str]
+    visual: NotRequired[_ExternalCoreOverlayVisual]
+    bounds: Required[_ExternalCoreOverlayBounds]
+
+class _ExternalCoreRequirementsImageAssetRequirements(TypedDict, total=False):
+    min_width: NotRequired[builtins.float]
+    max_width: NotRequired[builtins.float]
+    min_height: NotRequired[builtins.float]
+    max_height: NotRequired[builtins.float]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    parameters_from_format_id: NotRequired[builtins.bool]
+    unit: NotRequired[Literal['px', 'dp', 'inches', 'cm', 'mm', 'pt']]
+    aspect_ratio: NotRequired[builtins.str]
+    formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'avif', 'tiff', 'pdf', 'eps']]]
+    min_dpi: NotRequired[builtins.int]
+    bleed: NotRequired[_ExternalCoreRequirementsImageAssetRequirementsBleedVariant1 | _ExternalCoreRequirementsImageAssetRequirementsBleedVariant2]
+    color_space: NotRequired[Literal['rgb', 'cmyk', 'grayscale']]
+    max_file_size_kb: NotRequired[builtins.int]
+    transparency_required: NotRequired[builtins.bool]
+    animation_allowed: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_weight_grams: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsVideoAssetRequirements(TypedDict, total=False):
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    min_duration_ms: NotRequired[builtins.int]
+    max_duration_ms: NotRequired[builtins.int]
+    containers: NotRequired[builtins.list[Literal['mp4', 'webm', 'mov', 'avi', 'mkv']]]
+    codecs: NotRequired[builtins.list[Literal['h264', 'h265', 'vp8', 'vp9', 'av1', 'prores']]]
+    max_file_size_kb: NotRequired[builtins.int]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    frame_rates: NotRequired[builtins.list[builtins.float]]
+    audio_required: NotRequired[builtins.bool]
+    frame_rate_type: NotRequired[Literal['constant', 'variable']]
+    scan_type: NotRequired[Literal['progressive', 'interlaced']]
+    gop_type: NotRequired[Literal['closed', 'open']]
+    min_gop_interval_seconds: NotRequired[builtins.float]
+    max_gop_interval_seconds: NotRequired[builtins.float]
+    moov_atom_position: NotRequired[Literal['start', 'end']]
+    audio_codecs: NotRequired[builtins.list[Literal['aac', 'pcm', 'ac3', 'eac3', 'mp3', 'opus', 'vorbis', 'flac']]]
+    audio_sample_rates: NotRequired[builtins.list[builtins.int]]
+    audio_channels: NotRequired[builtins.list[Literal['mono', 'stereo', '5.1', '7.1']]]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsAudioAssetRequirements(TypedDict, total=False):
+    min_duration_ms: NotRequired[builtins.int]
+    max_duration_ms: NotRequired[builtins.int]
+    formats: NotRequired[builtins.list[Literal['mp3', 'aac', 'wav', 'ogg', 'flac']]]
+    max_file_size_kb: NotRequired[builtins.int]
+    sample_rates: NotRequired[builtins.list[builtins.int]]
+    channels: NotRequired[builtins.list[Literal['mono', 'stereo']]]
+    min_bitrate_kbps: NotRequired[builtins.int]
+    max_bitrate_kbps: NotRequired[builtins.int]
+    loudness_lufs: NotRequired[builtins.float]
+    loudness_tolerance_db: NotRequired[builtins.float]
+    true_peak_dbfs: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsTextAssetRequirements(TypedDict, total=False):
+    min_length: NotRequired[builtins.int]
+    max_length: NotRequired[builtins.int]
+    min_lines: NotRequired[builtins.int]
+    max_lines: NotRequired[builtins.int]
+    character_pattern: NotRequired[builtins.str]
+    prohibited_terms: NotRequired[builtins.list[builtins.str]]
+    allowed_values: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsMarkdownAssetRequirements(TypedDict, total=False):
+    max_length: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsHtmlAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+    sandbox: NotRequired[Literal['none', 'iframe', 'safeframe', 'fencedframe']]
+    external_resources_allowed: NotRequired[builtins.bool]
+    allowed_external_domains: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsCssAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+
+class _ExternalCoreRequirementsJavascriptAssetRequirements(TypedDict, total=False):
+    max_file_size_kb: NotRequired[builtins.int]
+    module_type: NotRequired[Literal['script', 'module', 'iife']]
+    strict_mode_required: NotRequired[builtins.bool]
+    external_resources_allowed: NotRequired[builtins.bool]
+    allowed_external_domains: NotRequired[builtins.list[builtins.str]]
+
+class _ExternalCoreRequirementsVastAssetRequirements(TypedDict, total=False):
+    vast_version: NotRequired[Literal['2.0', '3.0', '4.0', '4.1', '4.2', '4.3']]
+
+class _ExternalCoreRequirementsDaastAssetRequirements(TypedDict, total=False):
+    daast_version: NotRequired[Literal['1.0']]
+
+class _ExternalCoreRequirementsUrlAssetRequirements(TypedDict, total=False):
+    role: NotRequired[Literal['clickthrough', 'landing_page', 'impression_tracker', 'click_tracker', 'viewability_tracker', 'third_party_tracker']]
+    protocols: NotRequired[builtins.list[Literal['https', 'http']]]
+    allowed_domains: NotRequired[builtins.list[builtins.str]]
+    max_length: NotRequired[builtins.int]
+    macro_support: NotRequired[builtins.bool]
+
+class _ExternalCoreRequirementsWebhookAssetRequirements(TypedDict, total=False):
+    methods: NotRequired[builtins.list[Literal['GET', 'POST']]]
+
+class _ExternalCoreRequirementsCatalogRequirements(TypedDict, total=False):
+    catalog_type: Required[Literal['offering', 'product', 'inventory', 'store', 'promotion', 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app']]
+    required: NotRequired[builtins.bool]
+    min_items: NotRequired[builtins.int]
+    max_items: NotRequired[builtins.int]
+    required_fields: NotRequired[builtins.list[builtins.str]]
+    feed_formats: NotRequired[builtins.list[Literal['google_merchant_center', 'facebook_catalog', 'shopify', 'linkedin_jobs', 'tiktok_shop', 'pinterest_catalog', 'openai_product_feed', 'custom']]]
+    offering_asset_constraints: NotRequired[builtins.list[_ExternalCoreRequirementsOfferingAssetConstraint]]
+    field_bindings: NotRequired[builtins.list[_ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant1 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant2 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3]]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant1(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['image']]
+    requirements: NotRequired[_ExternalCoreRequirementsImageAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant2(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['video']]
+    requirements: NotRequired[_ExternalCoreRequirementsVideoAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant3(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['audio']]
+    requirements: NotRequired[_ExternalCoreRequirementsAudioAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant4(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['text']]
+    requirements: NotRequired[_ExternalCoreRequirementsTextAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant5(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['markdown']]
+    requirements: NotRequired[_ExternalCoreRequirementsMarkdownAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant6(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['html']]
+    requirements: NotRequired[_ExternalCoreRequirementsHtmlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant7(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['css']]
+    requirements: NotRequired[_ExternalCoreRequirementsCssAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant8(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['javascript']]
+    requirements: NotRequired[_ExternalCoreRequirementsJavascriptAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant9(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['zip']]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant10(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['vast']]
+    requirements: NotRequired[_ExternalCoreRequirementsVastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant11(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['daast']]
+    requirements: NotRequired[_ExternalCoreRequirementsDaastAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant12(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['url']]
+    requirements: NotRequired[_ExternalCoreRequirementsUrlAssetRequirements]
+
+class _ExternalCoreFormatAssetsItemVariant16AssetsItemVariant13(TypedDict, total=False):
+    asset_id: Required[builtins.str]
+    asset_role: NotRequired[builtins.str]
+    asset_group_id: NotRequired[builtins.str]
+    required: Required[builtins.bool]
+    overlays: NotRequired[builtins.list[_ExternalCoreOverlay]]
+    asset_type: Required[Literal['webhook']]
+    requirements: NotRequired[_ExternalCoreRequirementsWebhookAssetRequirements]
+
+class _ExternalCoreFormatPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreCanonicalProjectionSlotOverride(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[builtins.str]
+    required: NotRequired[builtins.bool]
+    max_chars: NotRequired[builtins.int]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreCreativeLocalizationReadbackLocaleFallbacksItem(TypedDict, total=False):
+    language_range: Required[builtins.str]
+    locale_variant_id: Required[builtins.str]
+
+class _ExternalCoreCreativeLocalizationReadbackVariantsItemVariant1(TypedDict, total=False):
+    locale_variant_id: Required[builtins.str]
+    locale: Required[builtins.str]
+    role: Required[Literal['source']]
+    assets: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeLocalizationReadbackVariantsItemVariant2(TypedDict, total=False):
+    locale_variant_id: Required[builtins.str]
+    locale: Required[builtins.str]
+    role: Required[Literal['target']]
+    assets: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationReference(TypedDict, total=False):
+    issuer: Required[_ExternalCoreRightsAttestationEvaluationReferenceIssuerVariant1 | _ExternalCoreRightsAttestationEvaluationReferenceIssuerVariant2 | _ExternalCoreRightsAttestationEvaluationReferenceIssuerVariant3]
+    claim_type: Required[Literal['https://adcontextprotocol.org/claims/rights/grant']]
+    subject: Required[_ExternalCoreRightsAttestationEvaluationReferenceSubjectVariant1 | _ExternalCoreRightsAttestationEvaluationReferenceSubjectVariant2 | _ExternalCoreRightsAttestationEvaluationReferenceSubjectVariant3]
+    locator: NotRequired[_ExternalCoreRightsAttestationEvaluationReferenceLocatorVariant1 | _ExternalCoreRightsAttestationEvaluationReferenceLocatorVariant2]
+    embedded_credential: NotRequired[_ExternalCoreRightsAttestationEvaluationReferenceEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_ExternalCoreRightsAttestationEvaluationReferenceValidityHint]
+    verify_agent: NotRequired[_ExternalCoreRightsAttestationEvaluationReferenceVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationEvaluation(TypedDict, total=False):
+    reference_digest: Required[builtins.str]
+    credential_digest: NotRequired[builtins.str]
+    proof_format: NotRequired[builtins.str]
+    outcome: Required[Literal['verified', 'not_found', 'expired', 'revoked', 'invalid', 'unsupported', 'unverifiable', 'untrusted_issuer', 'untrusted_resolver', 'subject_mismatch', 'digest_mismatch', 'resolution_failed']]
+    evaluated_at: Required[builtins.str]
+    evaluated_by: Required[builtins.str]
+    verifier_agent_url: NotRequired[builtins.str]
+    reason_codes: NotRequired[builtins.list[builtins.str]]
+    confidence: NotRequired[builtins.float]
+    revocation_checked_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    action_binding: Required[_ExternalCoreRightsAttestationEvaluationEvaluationActionBinding]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ListCreativesResponseCreativesItemVariant1AssignmentsAssignedPackagesItem(TypedDict, total=False):
+    indicators: NotRequired[builtins.list[_ExternalCoreIndicator]]
+    indicator_types_evaluated: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    indicators_as_of: NotRequired[builtins.str]
+    indicators_evaluated_scope: NotRequired[builtins.list[_ExternalCoreIndicatorScope]]
+    package_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    assigned_date: Required[builtins.str]
+    approval_status: NotRequired[Literal['pending_review', 'approved', 'partially_approved', 'rejected']]
+    rejection_reason: NotRequired[builtins.str]
+    approval_scopes: NotRequired[builtins.list[_ExternalCoreCreativeApprovalScope]]
+
+class _ListCreativesResponseCreativesItemVariant1PricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ListCreativesResponseCreativesItemVariant2AssignmentsAssignedPackagesItem(TypedDict, total=False):
+    indicators: NotRequired[builtins.list[_ExternalCoreIndicator]]
+    indicator_types_evaluated: NotRequired[builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']]]
+    indicators_as_of: NotRequired[builtins.str]
+    indicators_evaluated_scope: NotRequired[builtins.list[_ExternalCoreIndicatorScope]]
+    package_id: Required[builtins.str]
+    media_buy_id: NotRequired[builtins.str]
+    assigned_date: Required[builtins.str]
+    approval_status: NotRequired[Literal['pending_review', 'approved', 'partially_approved', 'rejected']]
+    rejection_reason: NotRequired[builtins.str]
+    approval_scopes: NotRequired[builtins.list[_ExternalCoreCreativeApprovalScope]]
+
+class _ListCreativesResponseCreativesItemVariant2PricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreProductOfferFiltersFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCoreProductOfferFiltersFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreBudgetRange(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreProductOfferFiltersTrustedMatch(TypedDict, total=False):
+    providers: NotRequired[builtins.list[_ExternalCoreProductOfferFiltersTrustedMatchProvidersItem]]
+    response_types: NotRequired[builtins.list[Literal['activation', 'catalog_items', 'creative', 'deal']]]
+
+class _ExternalCoreProductOfferFiltersRequiredFeatures(TypedDict, total=False):
+    property_filtering: NotRequired[builtins.bool]
+    catalog_management: NotRequired[builtins.bool]
+    reporting_commitment_snapshots: NotRequired[builtins.bool]
+    seller_optimized_budget: NotRequired[builtins.bool]
+    bidding_policy: NotRequired[_ExternalCoreBiddingPolicyCapability]
+
+class _ExternalCoreProductOfferFiltersRequiredPerformanceStandardsItem(TypedDict, total=False):
+    metric: Required[Literal['viewability', 'ivt', 'completion_rate', 'brand_safety', 'attention_score']]
+    threshold: Required[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+    vendor: Required[_ExternalCoreBrandKey]
+
+class _ExternalCoreProductOfferFiltersRequiredVendorMetricsItem(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandKey]
+    metric_id: NotRequired[builtins.str]
+
+class _ExternalCoreCanonicalForecastPoint(TypedDict, total=False):
+    label: NotRequired[builtins.str]
+    budget: NotRequired[builtins.float]
+    product_id: NotRequired[builtins.str]
+    dimensions: NotRequired[builtins.list[_ExternalCoreForecastPointDimensionsItemVariant1 | _ExternalCoreForecastPointDimensionsItemVariant2 | _ExternalCoreForecastPointDimensionsItemVariant3 | _ExternalCoreForecastPointDimensionsItemVariant4 | _ExternalCoreForecastPointDimensionsItemVariant5 | _ExternalCoreForecastPointDimensionsItemVariant6]]
+    metrics: Required[builtins.dict[builtins.str, _ExternalCoreForecastRange]]
+    viewability: NotRequired[_ExternalCoreCanonicalForecastPointViewability]
+    vendor_metric_values: NotRequired[builtins.list[_ExternalCoreCanonicalForecastVendorMetricValue]]
+
+class _ExternalCoreCanonicalReportingCapabilitiesVendorMetricsItem(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+
+class _ExternalCoreCanonicalAudienceEvidenceBaseline(TypedDict, total=False):
+    system: Required[builtins.str]
+    population_id: Required[builtins.str]
+    version: Required[builtins.str]
+    description: NotRequired[builtins.str]
+
+class _ExternalCoreTransformerVoiceSynthesisRefItemBrandAgent(TypedDict, total=False):
+    url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerParamOptionsItem(TypedDict, total=False):
+    value: Required[Any]
+    label: NotRequired[builtins.str]
+    metadata: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreUserMatchUidsItem(TypedDict, total=False):
+    type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]
+    value: Required[builtins.str]
+
+class _ExternalCoreEventCustomDataContentsItem(TypedDict, total=False):
+    id: Required[builtins.str]
+    quantity: NotRequired[builtins.int]
+    price: NotRequired[builtins.float]
+    brand: NotRequired[builtins.str]
+
+class _PackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _PreviewCreativeRequestRequestsItemCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemInput]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItem(TypedDict, total=False):
+    preview_id: Required[builtins.str]
+    renders: Required[builtins.list[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1 | _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2 | _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3]]
+    input: Required[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemInput]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponsePreviewsItem2RendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _ExternalMediaBuyProposalBudgetConstraint(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+    currency: Required[builtins.str]
+
+class _RefineProposalsRequestRefinementsItemVariant1ConstraintsCpm(TypedDict, total=False):
+    max: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _RefineProposalsRequestRefinementsItemVariant1ConstraintsImpressions(TypedDict, total=False):
+    min: Required[builtins.float]
+
+class _RefineProposalsRequestRefinementsItemVariant1ConstraintsFlight(TypedDict, total=False):
+    start_no_later_than: NotRequired[builtins.str]
+    end_no_earlier_than: NotRequired[builtins.str]
+
+class _RefineProposalsRequestRefinementsItemVariant2ConstraintsCpm(TypedDict, total=False):
+    max: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _RefineProposalsRequestRefinementsItemVariant2ConstraintsImpressions(TypedDict, total=False):
+    min: Required[builtins.float]
+
+class _RefineProposalsRequestRefinementsItemVariant2ConstraintsFlight(TypedDict, total=False):
+    start_no_later_than: NotRequired[builtins.str]
+    end_no_earlier_than: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextPayingPrincipalAccount(TypedDict, total=False):
+    account_id: Required[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextDisclosureObligationJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiIdentityUserShippingAddress(TypedDict, total=False):
+    street: NotRequired[builtins.str]
+    city: NotRequired[builtins.str]
+    state: NotRequired[builtins.str]
+    postal_code: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVoiceVariant2(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    voice_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesVideoVariant2(TypedDict, total=False):
+    formats: NotRequired[builtins.list[builtins.str]]
+    max_duration_seconds: NotRequired[builtins.int]
+
+class _ExternalSponsoredIntelligenceSiCapabilitiesModalitiesAvatarVariant2(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    avatar_id: NotRequired[builtins.str]
+
+class _ExternalSponsoredIntelligenceSiSponsoredContextReceiptHostReceiptDisclosureCommitment(TypedDict, total=False):
+    status: Required[Literal['accepted', 'not_required']]
+    label_text: NotRequired[builtins.str]
+    notes: NotRequired[builtins.str]
+
+class _ExternalA2uiComponent(TypedDict, total=False):
+    id: Required[builtins.str]
+    parentId: NotRequired[builtins.str]
+    component: Required[builtins.dict[builtins.str, builtins.dict[builtins.str, Any]]]
+
+class _SiSendMessageResponseHandoffIntentPrice(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    currency: NotRequired[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant1NotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _SyncAccountsRequestAccountsItemVariant2NotificationConfigsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: NotRequired[builtins.str]
+
+class _NonblockingImpactsItem(TypedDict, total=False):
+    area: Required[Literal['account_id', 'media_buys', 'reporting', 'approval', 'billing', 'grants', 'other']]
+    effect: Required[Literal['preserved', 'revalidation_required', 'revoke_and_regrant']]
+    reason: NotRequired[builtins.str]
+
+class _Impact(TypedDict, total=False):
+    area: Required[Literal['account_id', 'media_buys', 'reporting', 'approval', 'billing', 'grants', 'other']]
+    effect: Required[Literal['preserved', 'revalidation_required', 'revoke_and_regrant', 'blocked']]
+    reason: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceMemberUidsItem(TypedDict, total=False):
+    type: Required[Literal['rampid', 'rampid_derived', 'id5', 'uid2', 'euid', 'pairid', 'maid', 'hashed_email', 'publisher_first_party', 'world_id_nullifier', 'other']]
+    value: Required[builtins.str]
+
+class _ExternalCoreCatalogItemAvailabilityErrorIssuesItem(TypedDict, total=False):
+    pointer: Required[builtins.str]
+    message: Required[builtins.str]
+    keyword: Required[builtins.str]
+    schemaPath: NotRequired[builtins.str]
+    schema_id: NotRequired[builtins.str]
+    discriminator: NotRequired[builtins.list[_ExternalCoreCatalogItemAvailabilityErrorIssuesItemDiscriminatorItem]]
+
+class _SyncCatalogsResponseErrorsItemIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _ExternalCoreCreativeLocalizationSource(TypedDict, total=False):
+    locale_variant_id: Required[builtins.str]
+    locale: Required[builtins.str]
+
+class _ExternalCoreCreativeLocalizationTargetVariantsItem(TypedDict, total=False):
+    locale_variant_id: Required[builtins.str]
+    locale: Required[builtins.str]
+    assets: Required[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreCreativeLocalizationLocaleFallbacksItem(TypedDict, total=False):
+    language_range: Required[builtins.str]
+    locale_variant_id: Required[builtins.str]
+
+class _ExternalCoreEventSourceHealthDetail(TypedDict, total=False):
+    score: Required[builtins.float]
+    max_score: Required[builtins.float]
+    label: NotRequired[builtins.str]
+
+class _SyncGovernanceRequestAccountsItemGovernanceAgentsItemAuthentication(TypedDict, total=False):
+    schemes: Required[builtins.list[Literal['Bearer', 'HMAC-SHA256']]]
+    credentials: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemBudgetVariant1AllocationsValue(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _SyncPlansRequestPlansItemBudgetVariant2AllocationsValue(TypedDict, total=False):
+    amount: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _SyncPlansRequestPlansItemChannelsMixTargetsValue(TypedDict, total=False):
+    min_pct: NotRequired[builtins.float]
+    max_pct: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant2]
+    value_type: Required[Literal['binary']]
+    value: Required[builtins.bool]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant2]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3(TypedDict, total=False):
+    type: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant2 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant3]
+    signal_id: NotRequired[_ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant1 | _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant2]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant4(TypedDict, total=False):
+    type: Required[Literal['description']]
+    description: Required[builtins.str]
+    category: NotRequired[builtins.str]
+
+class _SyncPlansRequestPlansItemDelegationsItemBudgetLimit(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _SyncPlansRequestPlansItemPortfolioTotalBudgetCap(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksGetResponseAdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _TasksListRequestAccountVariant2BrandDataSubjectContestation(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    email: NotRequired[builtins.str]
+    languages: NotRequired[builtins.list[builtins.str]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverride(TypedDict, total=False):
+    logo: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogo]
+    colors: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideColors]
+    voice: NotRequired[builtins.str]
+    tagline: NotRequired[builtins.str]
+
+class _TasksListResponseAdcpErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant1(TypedDict, total=False):
+    type: Required[Literal['text']]
+    role: NotRequired[Literal['title', 'paragraph', 'heading', 'caption', 'quote', 'list_item', 'description']]
+    content: Required[builtins.str]
+    content_format: NotRequired[Literal['text/plain', 'text/markdown', 'text/html', 'application/json']]
+    language: NotRequired[builtins.str]
+    heading_level: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2(TypedDict, total=False):
+    type: Required[Literal['image']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3]
+    alt_text: NotRequired[builtins.str]
+    caption: NotRequired[builtins.str]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3(TypedDict, total=False):
+    type: Required[Literal['video']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'subtitles', 'closed_captions', 'dub', 'generated']]
+    thumbnail_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4(TypedDict, total=False):
+    type: Required[Literal['audio']]
+    url: Required[builtins.str]
+    access: NotRequired[_UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2 | _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3]
+    duration_ms: NotRequired[builtins.int]
+    transcript: NotRequired[builtins.str]
+    transcript_format: NotRequired[Literal['text/plain', 'text/markdown', 'application/json']]
+    transcript_source: NotRequired[Literal['original_script', 'closed_captions', 'generated']]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Metadata(TypedDict, total=False):
+    canonical: NotRequired[builtins.str]
+    author: NotRequired[builtins.str]
+    keywords: NotRequired[builtins.str]
+    open_graph: NotRequired[builtins.dict[builtins.str, Any]]
+    twitter_card: NotRequired[builtins.dict[builtins.str, Any]]
+    json_ld: NotRequired[builtins.list[builtins.dict[builtins.str, Any]]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2Identifiers(TypedDict, total=False):
+    apple_podcast_id: NotRequired[builtins.str]
+    spotify_collection_id: NotRequired[builtins.str]
+    podcast_guid: NotRequired[builtins.str]
+    youtube_video_id: NotRequired[builtins.str]
+    rss_url: NotRequired[builtins.str]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant1InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyPackageUpdateCreativesItemVariant2InputsItem(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemIssuerVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemIssuerVariant3(TypedDict, total=False):
+    type: Required[Never]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemSubjectVariant1(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemSubjectVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemSubjectVariant3(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _UpdateRightsResponseRightsConstraintAttestationRefsItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _ExternalPropertyValidationResultFeaturesItemRequirement(TypedDict, total=False):
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    allowed_values: NotRequired[builtins.list[Any]]
+
+class _ExternalPropertyAuthorizationResultViolation(TypedDict, total=False):
+    code: Required[builtins.str]
+    message: Required[builtins.str]
+
+class _SignedResponsePayloadResponse(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary', 'parent', 'property', 'trademark']]
+    verification_status: Required[Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown']]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    context_note: NotRequired[builtins.str]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _VerifyBrandClaimsRequestClaimsItemVariant3ClaimProperty(TypedDict, total=False):
+    type: Required[Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']]
+    identifier: Required[builtins.str]
+    store: NotRequired[Literal['apple', 'google', 'amazon', 'roku', 'fire_tv', 'samsung', 'lg', 'vizio', 'other']]
+    region: NotRequired[builtins.str]
+
+class _SignedResponse2PayloadResponse(TypedDict, total=False):
+    results: Required[builtins.list[_SignedResponse2PayloadResponseResultsItemVariant1 | _SignedResponse2PayloadResponseResultsItemVariant2]]
+    context: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemFormatOptionRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemFormatOptionRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant1Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant2Target]
+    attribution_window: NotRequired[_ExternalCoreAttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant3Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['metric']]
+    metric: Required[Literal['clicks', 'views', 'completed_views', 'viewed_seconds', 'engagements', 'follows', 'saves', 'profile_visits', 'reach']]
+    reach_unit: NotRequired[Literal['individuals', 'households', 'devices', 'accounts', 'cookies', 'custom']]
+    target_frequency: NotRequired[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency]
+    view_duration_seconds: NotRequired[builtins.float]
+    target: NotRequired[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant1Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['event']]
+    event_sources: Required[builtins.list[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem]]
+    target: NotRequired[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant2Target]
+    attribution_window: NotRequired[_ExternalCoreAttributionWindow]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['vendor_metric']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    target: NotRequired[_ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant3Target]
+    priority: NotRequired[builtins.int]
+
+class _ExternalMediaBuyCommercialTermsReportingCommitmentsItemMetricsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['standard']]
+    metric_id: Required[Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'quartile_data', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']]
+    qualifier: NotRequired[_ExternalCoreCanonicalMetricQualifier]
+    effective_at: NotRequired[builtins.str]
+
+class _ExternalMediaBuyCommercialTermsReportingCommitmentsItemMetricsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['vendor']]
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    qualifier: NotRequired[_ExternalCoreCanonicalMetricQualifier]
+    effective_at: NotRequired[builtins.str]
+
+class _ExternalMediaBuyCommercialTermsCancellationTermsFee(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreInsertionOrderTermsTotalBudget(TypedDict, total=False):
+    amount: Required[builtins.float]
+    currency: Required[builtins.str]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemIssuerVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemIssuerVariant3(TypedDict, total=False):
+    type: Required[Never]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemSubjectVariant1(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemSubjectVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemSubjectVariant3(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreRightsConstraintAttestationRefsItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _ExternalCoreProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _ExternalCoreProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_ExternalCoreProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreviewPreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _BuildCreativeResponsePreview2PreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _BuildCreativeResponseCreativesItemVariantsItemCreativeManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _CreateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _CreateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageRequestOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _CreateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreAttestationReference(TypedDict, total=False):
+    issuer: Required[_ExternalCoreAttestationReferenceIssuerVariant1 | _ExternalCoreAttestationReferenceIssuerVariant2 | _ExternalCoreAttestationReferenceIssuerVariant3]
+    claim_type: Required[builtins.str]
+    subject: Required[_ExternalCoreAttestationReferenceSubjectVariant1 | _ExternalCoreAttestationReferenceSubjectVariant2 | _ExternalCoreAttestationReferenceSubjectVariant3]
+    locator: NotRequired[_ExternalCoreAttestationReferenceLocatorVariant1 | _ExternalCoreAttestationReferenceLocatorVariant2]
+    embedded_credential: NotRequired[_ExternalCoreAttestationReferenceEmbeddedCredential]
+    content_digest: NotRequired[builtins.str]
+    credential_version: NotRequired[builtins.str]
+    validity_hint: NotRequired[_ExternalCoreAttestationReferenceValidityHint]
+    verify_agent: NotRequired[_ExternalCoreAttestationReferenceVerifyAgent]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceSelectionAttestationEvaluationsItemEvaluation(TypedDict, total=False):
+    reference_digest: Required[builtins.str]
+    credential_digest: NotRequired[builtins.str]
+    proof_format: NotRequired[builtins.str]
+    outcome: Required[Literal['verified', 'not_found', 'expired', 'revoked', 'invalid', 'unsupported', 'unverifiable', 'untrusted_issuer', 'untrusted_resolver', 'subject_mismatch', 'digest_mismatch', 'resolution_failed']]
+    evaluated_at: Required[builtins.str]
+    evaluated_by: Required[builtins.str]
+    verifier_agent_url: NotRequired[builtins.str]
+    reason_codes: NotRequired[builtins.list[builtins.str]]
+    confidence: NotRequired[builtins.float]
+    revocation_checked_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    action_binding: Required[_ExternalCoreAudienceEvidenceSelectionAttestationEvaluationsItemEvaluationActionBinding]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDemographicTargetingResolutionExecutionVariant1(TypedDict, total=False):
+    type: Required[Literal['continuous_bounds']]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDemographicTargetingResolutionExecutionVariant2(TypedDict, total=False):
+    type: Required[Literal['enumerated_intervals']]
+    interval_ids: Required[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDemographicTargetingResolutionExecutionVariant3(TypedDict, total=False):
+    type: Required[Literal['signals']]
+    signal_refs: Required[builtins.list[_ExternalCoreDemographicTargetingResolutionExecutionVariant3SignalRefsItemVariant1 | _ExternalCoreDemographicTargetingResolutionExecutionVariant3SignalRefsItemVariant2 | _ExternalCoreDemographicTargetingResolutionExecutionVariant3SignalRefsItemVariant3]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreDownstreamConnectionRequirement(TypedDict, total=False):
+    provider: NotRequired[builtins.str]
+    connection_type: Required[Literal['advertiser_account', 'publisher_identity', 'post_authorization']]
+    required_for: NotRequired[builtins.list[builtins.str]]
+    scope: NotRequired[Literal['account', 'identity', 'post', 'unknown']]
+    status: NotRequired[Literal['connected', 'missing', 'pending', 'expired', 'revoked', 'not_required', 'unknown']]
+    connection_id: NotRequired[builtins.str]
+    resource_ref: NotRequired[_ExternalCoreDownstreamConnectionRequirementResourceRef]
+    authorization_url: NotRequired[builtins.str]
+    authorization_instructions: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsToProvideItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalFormatsCanonicalImageCarouselSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalVideoHostedSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalVideoVastSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAudioHostedSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAudioDaastSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalSponsoredPlacementSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalNativeInFeedSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalNativeInFeedMainImageSizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalFormatsCanonicalNativeInFeedIconSize(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalFormatsCanonicalResponsiveCreativeSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalFormatsCanonicalAgentPlacementSlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePackageFormatsPendingItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePackageOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreAttestationCapabilitiesAcceptedIssuersItemIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationCapabilitiesAcceptedIssuersItemIssuerVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationCapabilitiesAcceptedIssuersItemIssuerVariant3(TypedDict, total=False):
+    type: Required[Literal['origin']]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationCapabilitiesAcceptedIssuersItemResolversItem(TypedDict, total=False):
+    resolver_id: Required[builtins.str]
+    url: Required[builtins.str]
+    authentication: Required[Literal['none', 'evaluator_managed']]
+
+class _ScopeCapability(TypedDict, total=False):
+    fixed: NotRequired[_PolicyProfile]
+    seller_optimized: NotRequired[_PolicyProfile]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoMetros(TypedDict, total=False):
+    nielsen_dma: NotRequired[builtins.bool]
+    uk_itl1: NotRequired[builtins.bool]
+    uk_itl2: NotRequired[builtins.bool]
+    eurostat_nuts2: NotRequired[builtins.bool]
+
+class _ExternalCorePostalAreaSupport(TypedDict, total=False):
+    US: NotRequired[builtins.list[Literal['zip', 'zip_plus_four']]]
+    GB: NotRequired[builtins.list[Literal['outward', 'full']]]
+    CA: NotRequired[builtins.list[Literal['fsa', 'full']]]
+    DE: NotRequired[builtins.list[Literal['plz']]]
+    CH: NotRequired[builtins.list[Literal['plz']]]
+    AT: NotRequired[builtins.list[Literal['plz']]]
+    FR: NotRequired[builtins.list[Literal['code_postal']]]
+    AU: NotRequired[builtins.list[Literal['postcode']]]
+    BR: NotRequired[builtins.list[Literal['cep']]]
+    IN: NotRequired[builtins.list[Literal['pin']]]
+    ZA: NotRequired[builtins.list[Literal['postal_code']]]
+    us_zip: NotRequired[builtins.bool]
+    us_zip_plus_four: NotRequired[builtins.bool]
+    gb_outward: NotRequired[builtins.bool]
+    gb_full: NotRequired[builtins.bool]
+    ca_fsa: NotRequired[builtins.bool]
+    ca_full: NotRequired[builtins.bool]
+    de_plz: NotRequired[builtins.bool]
+    fr_code_postal: NotRequired[builtins.bool]
+    au_postcode: NotRequired[builtins.bool]
+    ch_plz: NotRequired[builtins.bool]
+    at_plz: NotRequired[builtins.bool]
+
+class _ExternalCoreGeoPlaceSupport(TypedDict, total=False):
+    countries: Required[builtins.dict[builtins.str, builtins.list[Literal['airport', 'borough', 'city', 'city_region', 'commune', 'county', 'district', 'municipality', 'neighborhood', 'post_town', 'prefecture', 'province', 'quarter', 'state', 'territory', 'ward'] | builtins.str]]]
+    catalog: Required[_ExternalCoreGeoPlaceCatalogCapability]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingAgeRestriction(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    verification_methods: NotRequired[builtins.list[Literal['facial_age_estimation', 'id_document', 'digital_id', 'credit_card', 'world_id']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingDemographics(TypedDict, total=False):
+    supported: Required[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingLanguageVariant2(TypedDict, total=False):
+    supported: NotRequired[builtins.bool]
+    supported_languages: NotRequired[builtins.list[builtins.str]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingKeywordTargets(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingNegativeKeywords(TypedDict, total=False):
+    supported_match_types: Required[builtins.list[Literal['broad', 'phrase', 'exact']]]
+
+class _GetAdcpCapabilitiesResponseMediaBuyExecutionTargetingGeoProximity(TypedDict, total=False):
+    radius: NotRequired[builtins.bool]
+    travel_time: NotRequired[builtins.bool]
+    geometry: NotRequired[builtins.bool]
+    transport_modes: NotRequired[builtins.list[Literal['walking', 'cycling', 'driving', 'public_transport']]]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeVariantReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCreativeVariantDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCoreCreativeVariantManifestVariant1FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['publisher']]
+    publisher_domain: Required[builtins.str]
+    format_option_id: Required[builtins.str]
+
+class _ExternalCoreCreativeVariantManifestVariant2FormatOptionRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    format_option_id: Required[builtins.str]
+    publisher_domain: NotRequired[Never]
+
+class _ExternalCoreCreativeVariantGenerationContextArtifact(TypedDict, total=False):
+    property_id: Required[_ExternalCoreIdentifier]
+    artifact_id: Required[builtins.str]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemTotalsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemMissingMetricsItemVariant1Qualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCoreCatalogItemDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCatalogItemDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreCatalogItemDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreCatalogItemDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCatalogItemDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCatalogItemDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCatalogItemDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCatalogItemDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCatalogItemDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreCreativeDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreCreativeDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreCreativeDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreCreativeDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreCreativeDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCreativeDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreKeywordDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreKeywordDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreKeywordDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreKeywordDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreKeywordDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreKeywordDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_ExternalCoreGeoDeliveryMetricsReachWindowPeriod]
+
+class _ExternalCoreGeoDeliveryMetricsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _ExternalCoreGeoDeliveryMetricsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_ExternalCoreGeoDeliveryMetricsDoohMetricsVenueBreakdownItem]]
+
+class _ExternalCoreGeoDeliveryMetricsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreGeoDeliveryMetricsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByEventTypeItem(TypedDict, total=False):
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindow(TypedDict, total=False):
+    kind: Required[Literal['cumulative', 'period', 'rolling']]
+    period: NotRequired[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindowPeriod]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemQuartileData2(TypedDict, total=False):
+    q1_views: NotRequired[builtins.float]
+    q2_views: NotRequired[builtins.float]
+    q3_views: NotRequired[builtins.float]
+    q4_views: NotRequired[builtins.float]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetrics(TypedDict, total=False):
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+    screen_time_seconds: NotRequired[builtins.int]
+    sov_achieved: NotRequired[builtins.float]
+    calculation_notes: NotRequired[builtins.str]
+    venue_breakdown: NotRequired[builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetricsVenueBreakdownItem]]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[builtins.float]
+    viewable_impressions: NotRequired[builtins.float]
+    viewable_rate: NotRequired[builtins.float]
+    viewed_seconds: NotRequired[builtins.float]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemByActionSourceItem(TypedDict, total=False):
+    action_source: Required[Literal['website', 'app', 'offline', 'phone_call', 'chat', 'email', 'in_store', 'system_generated', 'other']]
+    event_source_id: NotRequired[builtins.str]
+    count: Required[builtins.float]
+    value: NotRequired[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemBiddingCostPer(TypedDict, total=False):
+    amount: Required[builtins.float]
+    strength: Required[Literal['cap', 'target']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemBiddingRoas(TypedDict, total=False):
+    value: Required[builtins.float]
+    strength: Required[Literal['floor', 'target']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreCreativeApprovalScope(TypedDict, total=False):
+    scope: Required[_ExternalCoreIndicatorScope]
+    approval_status: Required[Literal['pending_review', 'approved', 'rejected']]
+    rejection_reason: NotRequired[builtins.str]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _GetPlanAuditLogsResponsePlansItemSummaryDriftMetricsThresholds(TypedDict, total=False):
+    escalation_rate_max: NotRequired[builtins.float]
+    escalation_rate_min: NotRequired[builtins.float]
+    auto_approval_rate_max: NotRequired[builtins.float]
+    human_override_rate_max: NotRequired[builtins.float]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryStatementReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryStatementCanonicalPayload(TypedDict, total=False):
+    seller_reference: Required[builtins.str]
+    delivery_metrics: Required[builtins.dict[builtins.str, Any]]
+
+class _GetPlanAuditLogsResponsePlansItemEntriesItemDeliveryReportingPeriod(TypedDict, total=False):
+    start: Required[builtins.str]
+    end: Required[builtins.str]
+
+class _ExternalCoreAttestationEvaluation(TypedDict, total=False):
+    reference_digest: Required[builtins.str]
+    credential_digest: NotRequired[builtins.str]
+    proof_format: NotRequired[builtins.str]
+    outcome: Required[Literal['verified', 'not_found', 'expired', 'revoked', 'invalid', 'unsupported', 'unverifiable', 'untrusted_issuer', 'untrusted_resolver', 'subject_mismatch', 'digest_mismatch', 'resolution_failed']]
+    evaluated_at: Required[builtins.str]
+    evaluated_by: Required[builtins.str]
+    verifier_agent_url: NotRequired[builtins.str]
+    reason_codes: NotRequired[builtins.list[builtins.str]]
+    confidence: NotRequired[builtins.float]
+    revocation_checked_at: NotRequired[builtins.str]
+    valid_until: NotRequired[builtins.str]
+    action_binding: NotRequired[_ExternalCoreAttestationEvaluationActionBinding]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreProductFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SizesItem]]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    aspect_ratio: NotRequired[builtins.str]
+    max_file_size_kb: NotRequired[builtins.int]
+    image_formats: NotRequired[builtins.list[Literal['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg']]]
+    ssl_required: NotRequired[builtins.bool]
+    headline_max_chars: NotRequired[builtins.int]
+    body_text_max_chars: NotRequired[builtins.int]
+    cta_values: NotRequired[builtins.list[builtins.str]]
+    asset_source: NotRequired[Literal['buyer_uploaded', 'publisher_host_recorded', 'seller_pre_rendered_from_brief', 'seller_human_designed', 'agent_synthesized', 'publisher_owned_reference']]
+    buyer_asset_acceptance: NotRequired[Literal['accepted', 'rejected']]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    max_initial_load_kb: NotRequired[builtins.int]
+    max_polite_load_kb: NotRequired[builtins.int]
+    host_initiated_subload: NotRequired[builtins.bool]
+    max_animation_duration_ms: NotRequired[builtins.int]
+    max_cpu_load_percent: NotRequired[builtins.int]
+    mraid_required: NotRequired[builtins.bool]
+    mraid_version: NotRequired[Literal['2.0', '3.0']]
+    om_sdk_required: NotRequired[builtins.bool]
+    clicktag_macro: NotRequired[Literal['clickTag', 'clickTAG']]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    ssl_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: Required[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4(TypedDict, total=False):
+    experimental: NotRequired[builtins.bool]
+    deprecated: NotRequired[builtins.bool]
+    v1_translatable: NotRequired[builtins.bool]
+    since_version: NotRequired[builtins.str]
+    migration_target_version: NotRequired[builtins.str]
+    composition_model: NotRequired[Literal['deterministic', 'algorithmic']]
+    provenance_required: NotRequired[builtins.bool]
+    platform_extensions: NotRequired[builtins.list[_ExternalCorePlatformExtensionRef]]
+    synthesis_nondeterministic: NotRequired[builtins.bool]
+    slots: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SlotsItem]]
+    required_connections: NotRequired[builtins.list[_ExternalCoreDownstreamConnectionRequirement]]
+    reference_mutability: NotRequired[Literal['immutable_snapshot', 'mutable_requires_reapproval', 'mutable_auto_recheck']]
+    production_window_business_days: NotRequired[builtins.int]
+    width: NotRequired[builtins.int]
+    height: NotRequired[builtins.int]
+    sizes: NotRequired[builtins.list[_ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SizesItem]]
+    min_width: NotRequired[builtins.int]
+    max_width: NotRequired[builtins.int]
+    min_height: NotRequired[builtins.int]
+    max_height: NotRequired[builtins.int]
+    supported_tag_types: NotRequired[builtins.list[Literal['iframe', 'javascript', '1x1_redirect']]]
+    ssl_required: NotRequired[builtins.bool]
+    max_redirect_depth: NotRequired[builtins.int]
+    max_response_time_ms: NotRequired[builtins.int]
+    backup_image_required: NotRequired[builtins.bool]
+    backup_image_max_size_kb: NotRequired[builtins.int]
+    om_sdk_required: NotRequired[builtins.bool]
+
+class _ExternalCoreProductPricingOptionsItemVariant5ParametersViewThresholdVariant2(TypedDict, total=False):
+    duration_seconds: Required[builtins.int]
+
+class _ExternalCoreForecastPointDimensionsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['geo']]
+    geo_level: Required[Literal['country', 'region', 'metro', 'postal_area']]
+    system: NotRequired[builtins.str]
+    country: NotRequired[builtins.str]
+    geo_code: Required[builtins.str]
+    geo_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['placement']]
+    placement_ref: Required[_ExternalCorePlacementRef]
+    placement_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['device_type']]
+    device_type: Required[Literal['desktop', 'mobile', 'tablet', 'ctv', 'dooh', 'unknown']]
+
+class _ExternalCoreForecastPointDimensionsItemVariant4(TypedDict, total=False):
+    kind: Required[Literal['device_platform']]
+    device_platform: Required[Literal['ios', 'android', 'windows', 'macos', 'linux', 'chromeos', 'tvos', 'tizen', 'webos', 'fire_os', 'roku_os', 'unknown']]
+
+class _ExternalCoreForecastPointDimensionsItemVariant5(TypedDict, total=False):
+    kind: Required[Literal['audience']]
+    audience_id: Required[builtins.str]
+    audience_source: Required[Literal['synced', 'platform', 'third_party', 'lookalike', 'retargeting', 'unknown']]
+    audience_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6(TypedDict, total=False):
+    kind: Required[Literal['signal']]
+    signal_ref: NotRequired[_ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant1 | _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant2 | _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant3]
+    signal_id: NotRequired[builtins.str]
+    signal_value: NotRequired[builtins.str | builtins.float | builtins.bool | None]
+    presence: Required[Literal['present', 'absent']]
+    signal_name: NotRequired[builtins.str]
+    signal_value_name: NotRequired[builtins.str]
+
+class _ExternalCoreForecastPointMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_ExternalCoreForecastRange]
+    reach: NotRequired[_ExternalCoreForecastRange]
+    frequency: NotRequired[_ExternalCoreForecastRange]
+    impressions: NotRequired[_ExternalCoreForecastRange]
+    clicks: NotRequired[_ExternalCoreForecastRange]
+    spend: NotRequired[_ExternalCoreForecastRange]
+    views: NotRequired[_ExternalCoreForecastRange]
+    completed_views: NotRequired[_ExternalCoreForecastRange]
+    grps: NotRequired[_ExternalCoreForecastRange]
+    engagements: NotRequired[_ExternalCoreForecastRange]
+    follows: NotRequired[_ExternalCoreForecastRange]
+    saves: NotRequired[_ExternalCoreForecastRange]
+    profile_visits: NotRequired[_ExternalCoreForecastRange]
+    measured_impressions: NotRequired[_ExternalCoreForecastRange]
+    downloads: NotRequired[_ExternalCoreForecastRange]
+    plays: NotRequired[_ExternalCoreForecastRange]
+    coverage_rate: NotRequired[_ExternalCoreForecastPointMetricsCoverageRate]
+
+class _ExternalCoreForecastPointViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_rate: NotRequired[_ExternalCoreForecastPointViewabilityViewableRate]
+    viewed_seconds: NotRequired[_ExternalCoreForecastRange]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreForecastVendorMetricValue(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandRef]
+    metric_id: Required[builtins.str]
+    value: Required[_ExternalCoreForecastRange]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreDemographicReportingCapabilityAge(TypedDict, total=False):
+    reporting_modes: Required[builtins.list[Literal['exact_predicates', 'enumerated_intervals']]]
+    min_reportable_age: NotRequired[builtins.int]
+    max_reportable_age: NotRequired[builtins.int]
+    supports_unbounded_min: NotRequired[builtins.bool]
+    supports_unbounded_max: NotRequired[builtins.bool]
+    intervals: NotRequired[builtins.list[_ExternalCoreDemographicReportingCapabilityAgeIntervalsItem]]
+
+class _ExternalCoreProductSignalTargetingOptionPricingOptionsItemVariant5Metadata(TypedDict, total=False):
+    summary_for_operator: NotRequired[builtins.str]
+
+class _ExternalCoreDemographicTargetingCapabilityAgeIntervalsItem(TypedDict, total=False):
+    interval_id: Required[builtins.str]
+    age: Required[_ExternalCoreDemographicAgeRange]
+
+class _ExternalCoreGeoRegionSupportCountriesValueVariant1(TypedDict, total=False):
+    all_values: Required[Literal[True]]
+
+class _ExternalCoreGeoRegionSupportCountriesValueVariant2(TypedDict, total=False):
+    values: Required[builtins.list[builtins.str]]
+
+class _PlaceCatalogSupport(TypedDict, total=False):
+    countries: Required[builtins.dict[builtins.str, builtins.list[Literal['airport', 'borough', 'city', 'city_region', 'commune', 'county', 'district', 'municipality', 'neighborhood', 'post_town', 'prefecture', 'province', 'quarter', 'state', 'territory', 'ward'] | builtins.str]]]
+    current_version: Required[builtins.str]
+    system_versions: Required[builtins.list[builtins.str]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreProductTargetingResolutionModificationsItemVariant2Selector(TypedDict, total=False):
+    country: Required[builtins.str]
+    system: Required[builtins.str]
+
+class _ExternalCoreAudienceCharacteristicRange(TypedDict, total=False):
+    min: NotRequired[builtins.float]
+    max: NotRequired[builtins.float]
+
+class _ExternalCoreAudienceCharacteristicTaxonomy(TypedDict, total=False):
+    system: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    value_id: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemIssuerVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemIssuerVariant3(TypedDict, total=False):
+    type: Required[Literal['origin']]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant1(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    content_digest: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant2(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    agent_url: Required[builtins.str]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    content_digest: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant3(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant4(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    content_digest: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant5(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    content_digest: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant6(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant7(TypedDict, total=False):
+    type: Required[Never]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant8(TypedDict, total=False):
+    type: Required[Never]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    agent_url: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemSubjectVariant9(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/audience-evidence']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAudienceEvidenceAttestationRefsItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _ExternalCoreProductCardReferenceAssetAssetVariant1(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    pixel_ratio: NotRequired[builtins.float]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalCoreProductCardReferenceAssetAssetVariant2(TypedDict, total=False):
+    asset_type: Required[Literal['video']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    duration_ms: NotRequired[builtins.int]
+    file_size_bytes: NotRequired[builtins.int]
+    container_format: NotRequired[builtins.str]
+    video_codec: NotRequired[builtins.str]
+    video_bitrate_kbps: NotRequired[builtins.int]
+    frame_rate: NotRequired[builtins.str]
+    frame_rate_type: NotRequired[Literal['constant', 'variable']]
+    scan_type: NotRequired[Literal['progressive', 'interlaced']]
+    color_space: NotRequired[Literal['rec709', 'rec2020', 'rec2100', 'srgb', 'dci_p3']]
+    hdr_format: NotRequired[Literal['sdr', 'hdr10', 'hdr10_plus', 'hlg', 'dolby_vision']]
+    chroma_subsampling: NotRequired[Literal['4:2:0', '4:2:2', '4:4:4']]
+    video_bit_depth: NotRequired[Literal[8, 10, 12]]
+    gop_interval_seconds: NotRequired[builtins.float]
+    gop_type: NotRequired[Literal['closed', 'open']]
+    moov_atom_position: NotRequired[Literal['start', 'end']]
+    has_audio: NotRequired[builtins.bool]
+    audio_codec: NotRequired[builtins.str]
+    audio_sampling_rate_hz: NotRequired[builtins.int]
+    audio_channels: NotRequired[Literal['mono', 'stereo', '5.1', '7.1']]
+    audio_bit_depth: NotRequired[Literal[16, 24, 32]]
+    audio_bitrate_kbps: NotRequired[builtins.int]
+    audio_loudness_lufs: NotRequired[builtins.float]
+    audio_true_peak_dbfs: NotRequired[builtins.float]
+    captions_url: NotRequired[builtins.str]
+    transcript_url: NotRequired[builtins.str]
+    audio_description_url: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalCoreProductCardReferenceAssetAssetVariant3(TypedDict, total=False):
+    asset_type: Required[Literal['markdown']]
+    content: Required[builtins.str]
+    language: NotRequired[builtins.str]
+    markdown_flavor: NotRequired[Literal['commonmark', 'gfm']]
+    allow_raw_html: NotRequired[builtins.bool]
+
+class _ExternalCoreProductCardReferenceAssetAssetVariant4(TypedDict, total=False):
+    asset_type: Required[Literal['url']]
+    url: Required[builtins.str]
+    url_type: NotRequired[Literal['clickthrough', 'tracker_pixel', 'tracker_script']]
+    description: NotRequired[builtins.str]
+    provenance: NotRequired[_ExternalCoreProvenance]
+
+class _ExternalCoreMaterialDeadline(TypedDict, total=False):
+    stage: Required[builtins.str]
+    due_at: Required[builtins.str]
+    label: NotRequired[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1(TypedDict, total=False):
+    signal_ref: Required[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant3]
+    value_type: Required[Literal['binary']]
+    value: Required[Literal[True]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant2]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2(TypedDict, total=False):
+    signal_ref: Required[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant3]
+    value_type: Required[Literal['categorical']]
+    values: Required[builtins.list[builtins.str]]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant2]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3(TypedDict, total=False):
+    signal_ref: Required[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant2 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant3]
+    value_type: Required[Literal['numeric']]
+    min_value: NotRequired[builtins.float]
+    max_value: NotRequired[builtins.float]
+    pricing_option_id: NotRequired[builtins.str]
+    signal_agent_segment_id: NotRequired[builtins.str]
+    activation_key: NotRequired[_ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant1 | _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant2]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['per_ad_spend']]
+    value: Required[builtins.float]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2TargetVariant3(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindow(TypedDict, total=False):
+    post_click: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick]
+    post_view: NotRequired[_ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView]
+    model: NotRequired[Literal['last_touch', 'first_touch', 'linear', 'time_decay', 'data_driven']]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant1(TypedDict, total=False):
+    kind: Required[Literal['cost_per']]
+    value: Required[builtins.float]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant3TargetVariant2(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreSignalModelingDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    disclosure_text: NotRequired[builtins.str]
+    disclosure_url: NotRequired[builtins.str]
+    audience: NotRequired[Literal['buyer', 'data_subject', 'regulator', 'public']]
+
+class _ExternalCoreSignalCoverageForecastPointsItemMetrics(TypedDict, total=False):
+    audience_size: NotRequired[_ExternalCoreForecastRange]
+    reach: NotRequired[_ExternalCoreForecastRange]
+    frequency: NotRequired[_ExternalCoreForecastRange]
+    impressions: NotRequired[_ExternalCoreForecastRange]
+    clicks: NotRequired[_ExternalCoreForecastRange]
+    spend: NotRequired[_ExternalCoreForecastRange]
+    views: NotRequired[_ExternalCoreForecastRange]
+    completed_views: NotRequired[_ExternalCoreForecastRange]
+    grps: NotRequired[_ExternalCoreForecastRange]
+    engagements: NotRequired[_ExternalCoreForecastRange]
+    follows: NotRequired[_ExternalCoreForecastRange]
+    saves: NotRequired[_ExternalCoreForecastRange]
+    profile_visits: NotRequired[_ExternalCoreForecastRange]
+    measured_impressions: NotRequired[_ExternalCoreForecastRange]
+    downloads: NotRequired[_ExternalCoreForecastRange]
+    plays: NotRequired[_ExternalCoreForecastRange]
+    coverage_rate: Required[_ExternalCoreSignalCoverageForecastPointsItemMetricsCoverageRate]
+
+class _ExternalCoreSignalCoverageForecastPointsItemViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandRef]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_rate: NotRequired[_ExternalCoreSignalCoverageForecastPointsItemViewabilityViewableRate]
+    viewed_seconds: NotRequired[_ExternalCoreForecastRange]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreFormatRendersItemVariant1DimensionsResponsive(TypedDict, total=False):
+    width: Required[builtins.bool]
+    height: Required[builtins.bool]
+
+class _ExternalCoreFormatRendersItemVariant2DimensionsResponsive(TypedDict, total=False):
+    width: Required[builtins.bool]
+    height: Required[builtins.bool]
+
+class _ExternalCoreOverlayVisual(TypedDict, total=False):
+    url: NotRequired[builtins.str]
+    light: NotRequired[builtins.str]
+    dark: NotRequired[builtins.str]
+
+class _ExternalCoreOverlayBounds(TypedDict, total=False):
+    x: Required[builtins.float]
+    y: Required[builtins.float]
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+    unit: Required[Literal['px', 'fraction', 'inches', 'cm', 'mm', 'pt']]
+
+class _ExternalCoreRequirementsImageAssetRequirementsBleedVariant1(TypedDict, total=False):
+    uniform: Required[builtins.float]
+
+class _ExternalCoreRequirementsImageAssetRequirementsBleedVariant2(TypedDict, total=False):
+    top: Required[builtins.float]
+    right: Required[builtins.float]
+    bottom: Required[builtins.float]
+    left: Required[builtins.float]
+
+class _ExternalCoreRequirementsOfferingAssetConstraint(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'zip', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']]
+    required: NotRequired[builtins.bool]
+    min_count: NotRequired[builtins.int]
+    max_count: NotRequired[builtins.int]
+    asset_requirements: NotRequired[builtins.dict[builtins.str, Any]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['scalar']]
+    asset_id: Required[builtins.str]
+    catalog_field: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['asset_pool']]
+    asset_id: Required[builtins.str]
+    asset_group_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3(TypedDict, total=False):
+    kind: Required[Literal['catalog_group']]
+    format_group_id: Required[builtins.str]
+    catalog_item: Required[Literal[True]]
+    per_item_bindings: NotRequired[builtins.list[_ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant1 | _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant2]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreFormatCanonicalParametersVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceIssuerVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceIssuerVariant3(TypedDict, total=False):
+    type: Required[Never]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    brand: Required[_ExternalCoreBrandRef]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceSubjectVariant1(TypedDict, total=False):
+    type: Required[Never]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceSubjectVariant2(TypedDict, total=False):
+    type: Required[Never]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceSubjectVariant3(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[Literal['https://adcontextprotocol.org/claims/subjects/rights-grant']]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreRightsAttestationEvaluationReferenceVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _ExternalCoreRightsAttestationEvaluationEvaluationActionBinding(TypedDict, total=False):
+    action_type: Required[Literal['https://adcontextprotocol.org/actions/rights-grant-evaluation']]
+
+class _ExternalCoreProductOfferFiltersTrustedMatchProvidersItem(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    context_match: NotRequired[builtins.bool]
+    identity_match: NotRequired[builtins.bool]
+
+class _ExternalCoreBiddingPolicyCapability(TypedDict, total=False):
+    media_buy: NotRequired[_ScopeCapability]
+    package: NotRequired[_ScopeCapability]
+
+class _ExternalCoreForecastRange(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreCanonicalForecastPointViewability(TypedDict, total=False):
+    vendor: NotRequired[_ExternalCoreBrandKey]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_impressions: NotRequired[_ExternalCoreForecastRange]
+    viewable_rate: NotRequired[_ExternalCoreForecastRange]
+    viewed_seconds: NotRequired[_ExternalCoreForecastRange]
+    standard: NotRequired[Literal['mrc', 'groupm']]
+
+class _ExternalCoreCanonicalForecastVendorMetricValue(TypedDict, total=False):
+    vendor: Required[_ExternalCoreBrandKey]
+    metric_id: Required[builtins.str]
+    value: Required[_ExternalCoreForecastRange]
+    unit: NotRequired[builtins.str]
+    measurable_impressions: NotRequired[_ExternalCoreForecastRange]
+    breakdown: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCoreTransformerInputFormatsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['url']]
+    preview_url: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['html']]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3(TypedDict, total=False):
+    render_id: Required[builtins.str]
+    output_format: Required[Literal['both']]
+    preview_url: Required[builtins.str]
+    preview_html: Required[builtins.str]
+    role: Required[builtins.str]
+    dimensions: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Dimensions]
+    embedding: NotRequired[_PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Embedding]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemInput(TypedDict, total=False):
+    name: Required[builtins.str]
+    macros: NotRequired[builtins.dict[builtins.str, builtins.str]]
+    context_description: NotRequired[builtins.str]
+
+class _ExternalCoreCatalogItemAvailabilityErrorIssuesItemDiscriminatorItem(TypedDict, total=False):
+    property_name: Required[builtins.str]
+    value: Required[builtins.str | builtins.float | builtins.bool | None]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsIncludeItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant1SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant2SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant1(TypedDict, total=False):
+    source: Required[Literal['catalog']]
+    data_provider_domain: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _ExternalGovernanceAudienceConstraintsExcludeItemVariant3SignalIdVariant2(TypedDict, total=False):
+    source: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    id: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    pixel_ratio: NotRequired[builtins.float]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogo(TypedDict, total=False):
+    asset_type: Required[Literal['image']]
+    url: Required[builtins.str]
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+    pixel_ratio: NotRequired[builtins.float]
+    format: NotRequired[builtins.str]
+    alt_text: NotRequired[builtins.str]
+    provenance: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenance]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideColors(TypedDict, total=False):
+    primary: NotRequired[builtins.str]
+    secondary: NotRequired[builtins.str]
+    accent: NotRequired[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant2AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant3AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant1(TypedDict, total=False):
+    method: Required[Literal['bearer_token']]
+    token: Required[builtins.str]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant2(TypedDict, total=False):
+    method: Required[Literal['service_account']]
+    provider: Required[Literal['gcp', 'aws']]
+    credentials: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _UpdateContentStandardsRequestCalibrationExemplarsFailItemVariant2AssetsItemVariant4AccessVariant3(TypedDict, total=False):
+    method: Required[Literal['signed_url']]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _UpdateMediaBuyRequestBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalMediaBuyPackageUpdateOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _UpdateMediaBuyResponseBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _SignedResponse2PayloadResponseResultsItemVariant1(TypedDict, total=False):
+    claim_type: Required[Literal['subsidiary', 'parent', 'property', 'trademark']]
+    status: Required[Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown']]
+    details: NotRequired[builtins.dict[builtins.str, Any]]
+    context_note: NotRequired[builtins.str]
+
+class _SignedResponse2PayloadResponseResultsItemVariant2(TypedDict, total=False):
+    error: Required[_ExternalCoreError]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreDuration]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant1Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant2Target(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyCommercialTermsPurchasesItemOptimizationGoalsItemVariant3Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequency(TypedDict, total=False):
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    window: Required[_ExternalCoreDuration]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant1Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant2EventSourcesItem(TypedDict, total=False):
+    event_source_id: Required[builtins.str]
+    event_type: Required[Literal['page_view', 'view_content', 'select_content', 'select_item', 'search', 'share', 'add_to_cart', 'remove_from_cart', 'viewed_cart', 'add_to_wishlist', 'initiate_checkout', 'add_payment_info', 'purchase', 'refund', 'lead', 'qualify_lead', 'close_convert_lead', 'disqualify_lead', 'complete_registration', 'subscribe', 'follow', 'content_view', 'watch_milestone', 'start_trial', 'app_install', 'app_launch', 'contact', 'schedule', 'donate', 'submit_application', 'custom']]
+    custom_event_name: NotRequired[builtins.str]
+    value_field: NotRequired[builtins.str]
+    value_factor: NotRequired[builtins.float]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant2Target(TypedDict, total=False):
+    kind: Required[Literal['maximize_value']]
+
+class _ExternalMediaBuyCommercialTermsBudgetAllocationVariant2OptimizationGoalsItemVariant3Target(TypedDict, total=False):
+    kind: Required[Literal['threshold_rate']]
+    value: Required[builtins.float]
+
+class _ExternalCoreCanonicalMetricQualifier(TypedDict, total=False):
+    viewability_standard: NotRequired[Literal['mrc', 'groupm']]
+    completion_source: NotRequired[Literal['seller_attested', 'vendor_attested']]
+    attribution_methodology: NotRequired[Literal['deterministic_purchase', 'probabilistic', 'panel_based', 'modeled']]
+    attribution_window: NotRequired[_ExternalCoreDuration]
+    lift_dimension: NotRequired[Literal['awareness', 'consideration', 'favorability', 'purchase_intent', 'ad_recall']]
+
+class _ExternalCoreProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCorePlannedDeliveryBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreAttestationReferenceIssuerVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceIssuerVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceIssuerVariant3(TypedDict, total=False):
+    type: Required[Literal['origin']]
+    origin: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceSubjectVariant1(TypedDict, total=False):
+    type: Required[Literal['brand']]
+    brand: Required[_ExternalCoreBrandRef]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceSubjectVariant2(TypedDict, total=False):
+    type: Required[Literal['agent']]
+    agent_url: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceSubjectVariant3(TypedDict, total=False):
+    type: Required[Literal['resource']]
+    resource_type: Required[builtins.str]
+    namespace: Required[builtins.str]
+    id: Required[builtins.str]
+    content_digest: NotRequired[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceLocatorVariant1(TypedDict, total=False):
+    type: Required[Literal['credential_uri']]
+    credential_uri: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceLocatorVariant2(TypedDict, total=False):
+    type: Required[Literal['issuer_credential_id']]
+    credential_id: Required[builtins.str]
+    resolver_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceEmbeddedCredential(TypedDict, total=False):
+    format: Required[builtins.str]
+    value: Required[builtins.dict[builtins.str, Any] | builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreAttestationReferenceValidityHint(TypedDict, total=False):
+    not_before: NotRequired[builtins.str]
+    expires_at: NotRequired[builtins.str]
+
+class _ExternalCoreAttestationReferenceVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+
+class _ExternalCoreAudienceEvidenceSelectionAttestationEvaluationsItemEvaluationActionBinding(TypedDict, total=False):
+    action_type: Required[Literal['https://adcontextprotocol.org/actions/audience-evidence-evaluation']]
+    action_id: Required[builtins.str]
+    action_digest: Required[builtins.str]
+
+class _ExternalCoreDemographicTargetingResolutionExecutionVariant3SignalRefsItemVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreDemographicTargetingResolutionExecutionVariant3SignalRefsItemVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreDemographicTargetingResolutionExecutionVariant3SignalRefsItemVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreDownstreamConnectionRequirementResourceRef(TypedDict, total=False):
+    platform_account_id: NotRequired[builtins.str]
+    identity_id: NotRequired[builtins.str]
+    handle: NotRequired[builtins.str]
+    profile_url: NotRequired[builtins.str]
+    post_id: NotRequired[builtins.str]
+    post_url: NotRequired[builtins.str]
+
+class _PolicyProfile(TypedDict, total=False):
+    modes: NotRequired[builtins.list[Literal['automatic', 'bid_amount', 'max_bid', 'cost_per', 'roas']]]
+    cost_per_strengths: NotRequired[builtins.list[Literal['cap', 'target']]]
+    roas_strengths: NotRequired[builtins.list[Literal['floor', 'target']]]
+    supported_combinations: NotRequired[builtins.list[_PolicyProfileSupportedCombinationsItemVariant1 | _PolicyProfileSupportedCombinationsItemVariant2]]
+
+class _ExternalCoreGeoPlaceCatalogCapability(TypedDict, total=False):
+    source: NotRequired[builtins.str]
+    current_version: Required[builtins.str]
+    supported_versions: Required[builtins.list[builtins.str]]
+    resolver: Required[_ExternalCoreGeoPlaceResolver]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetAdcpCapabilitiesResponseCreativeSupportedFormatsItemFormatVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreCatalogItemDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCatalogItemDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreCreativeDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreCreativeDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreKeywordDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreKeywordDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _ExternalCoreGeoDeliveryMetricsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreGeoDeliveryMetricsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDeviceTypeItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDevicePlatformItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByAudienceItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByDemographicItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemByPlacementItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemByPackageItemBySpotItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemTotalsDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemReachWindowPeriod(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuyDeliveryResponseMediaBuyDeliveriesItemWindowsItemByPackageItemDoohMetricsVenueBreakdownItem(TypedDict, total=False):
+    venue_id: Required[builtins.str]
+    venue_name: NotRequired[builtins.str]
+    venue_type: NotRequired[builtins.str]
+    impressions: Required[builtins.int]
+    loop_plays: NotRequired[builtins.int]
+    screens_used: NotRequired[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuysResponseMediaBuysItemBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemOptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsToProvideItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _GetMediaBuysResponseMediaBuysItemPackagesItemFormatsPendingItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreAttestationEvaluationActionBinding(TypedDict, total=False):
+    action_type: Required[builtins.str]
+    action_id: NotRequired[builtins.str]
+    action_digest: NotRequired[builtins.str]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant1ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant2ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant1SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant2SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant3SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SlotsItem(TypedDict, total=False):
+    asset_group_id: Required[builtins.str]
+    asset_type: Required[Literal['image', 'video', 'audio', 'text', 'markdown', 'url', 'html', 'css', 'javascript', 'vast', 'daast', 'webhook', 'brief', 'catalog', 'published_post', 'zip', 'card', 'object', 'pixel_tracker', 'vast_tracker', 'daast_tracker']]
+    required: NotRequired[builtins.bool]
+    min: NotRequired[builtins.int]
+    max: NotRequired[builtins.int]
+    max_chars: NotRequired[builtins.int]
+    max_size_kb: NotRequired[builtins.int]
+    pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    required_pixel_ratios: NotRequired[builtins.list[builtins.float]]
+    logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    required_logo_slots: NotRequired[builtins.list[Literal['logo_card_light', 'logo_card_dark', 'profile_mark', 'favicon', 'app_icon', 'social_profile_mark', 'nav_header', 'footer', 'email_header', 'watermark', 'ad_end_card', 'co_brand_lockup', 'marketplace_listing']]]
+    description: NotRequired[builtins.str]
+    consumed_for_production: NotRequired[builtins.bool]
+
+class _ExternalCorePlacementFormatOptionsItemVariant3ParamsVariant4SizesItem(TypedDict, total=False):
+    width: Required[builtins.int]
+    height: Required[builtins.int]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreForecastPointDimensionsItemVariant6SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCoreForecastPointMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreForecastPointViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreDemographicReportingCapabilityAgeIntervalsItem(TypedDict, total=False):
+    age: Required[_ExternalCoreDemographicAgeRange]
+    demographic: NotRequired[builtins.str]
+    demographic_system: NotRequired[Literal['nielsen', 'barb', 'agf', 'oztam', 'mediametrie', 'custom']]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant1ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant2ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant1(TypedDict, total=False):
+    scope: Required[Literal['product']]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant2(TypedDict, total=False):
+    scope: Required[Literal['data_provider']]
+    data_provider_domain: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3SignalRefVariant3(TypedDict, total=False):
+    scope: Required[Literal['signal_source']]
+    signal_source_url: Required[builtins.str]
+    signal_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant1(TypedDict, total=False):
+    type: Required[Literal['segment_id']]
+    segment_id: Required[builtins.str]
+
+class _ExternalCorePackageSignalTargetingGroupSignalsItemVariant3ActivationKeyVariant2(TypedDict, total=False):
+    type: Required[Literal['key_value']]
+    key: Required[builtins.str]
+    value: Required[builtins.str]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant1TargetFrequencyWindow(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostClick(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreProposalBudgetAllocationVariant2OptimizationGoalsItemVariant2AttributionWindowPostView(TypedDict, total=False):
+    interval: Required[builtins.int]
+    unit: Required[Literal['seconds', 'minutes', 'hours', 'days', 'campaign']]
+
+class _ExternalCoreSignalCoverageForecastPointsItemMetricsCoverageRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreSignalCoverageForecastPointsItemViewabilityViewableRate(TypedDict, total=False):
+    low: NotRequired[builtins.float]
+    mid: NotRequired[builtins.float]
+    high: NotRequired[builtins.float]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['scalar']]
+    asset_id: Required[builtins.str]
+    catalog_field: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _ExternalCoreRequirementsCatalogRequirementsFieldBindingsItemVariant3PerItemBindingsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['asset_pool']]
+    asset_id: Required[builtins.str]
+    asset_group_id: Required[builtins.str]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant1ResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant1Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant2Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Dimensions(TypedDict, total=False):
+    width: Required[builtins.float]
+    height: Required[builtins.float]
+
+class _PreviewCreativeResponseResultsItemVariant2ResponsePreviewsItemRendersItemVariant3Embedding(TypedDict, total=False):
+    recommended_sandbox: NotRequired[builtins.str]
+    requires_https: NotRequired[builtins.bool]
+    supports_fullscreen: NotRequired[builtins.bool]
+    csp_policy: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    synthetic_depiction: NotRequired[builtins.bool]
+    ai_tool: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenance(TypedDict, total=False):
+    digital_source_type: NotRequired[Literal['digital_capture', 'digital_creation', 'trained_algorithmic_media', 'composite_with_trained_algorithmic_media', 'algorithmic_media', 'composite_capture', 'composite_synthetic', 'human_edits', 'data_driven_media']]
+    synthetic_depiction: NotRequired[builtins.bool]
+    ai_tool: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool]
+    human_oversight: NotRequired[Literal['none', 'prompt_only', 'selected', 'edited', 'directed']]
+    declared_by: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy]
+    declared_at: NotRequired[builtins.str]
+    created_time: NotRequired[builtins.str]
+    c2pa: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa]
+    embedded_provenance: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem]]
+    watermarks: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem]]
+    disclosure: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure]
+    verification: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _PolicyProfileSupportedCombinationsItemVariant1(TypedDict, total=False):
+    kind: Required[Literal['max_bid_with_cost_per']]
+    cost_per_strengths: Required[builtins.list[Literal['cap', 'target']]]
+
+class _PolicyProfileSupportedCombinationsItemVariant2(TypedDict, total=False):
+    kind: Required[Literal['max_bid_with_roas']]
+    roas_strengths: Required[builtins.list[Literal['floor', 'target']]]
+
+class _ExternalCoreGeoPlaceResolver(TypedDict, total=False):
+    url: Required[builtins.str]
+    auth: Required[Literal['none', 'seller_credentials']]
+    protocol: Required[Literal['adcp_geo_place_resolver_v1']]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceAiTool(TypedDict, total=False):
+    name: Required[builtins.str]
+    version: NotRequired[builtins.str]
+    provider: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDeclaredBy(TypedDict, total=False):
+    agent_url: NotRequired[builtins.str]
+    role: Required[Literal['creator', 'advertiser', 'agency', 'platform', 'tool']]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceC2pa(TypedDict, total=False):
+    manifest_url: Required[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItem(TypedDict, total=False):
+    method: Required[Literal['manifest_wrapper', 'provenance_markers']]
+    standard: NotRequired[builtins.str]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItem(TypedDict, total=False):
+    media_type: Required[Literal['audio', 'image', 'video', 'text']]
+    provider: Required[builtins.str]
+    verify_agent: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent]
+    c2pa_action: NotRequired[Literal['c2pa.watermarked.bound', 'c2pa.watermarked.unbound']]
+    embedded_at: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosure(TypedDict, total=False):
+    required: Required[builtins.bool]
+    jurisdictions: NotRequired[builtins.list[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceVerificationItem(TypedDict, total=False):
+    verified_by: Required[builtins.str]
+    verified_time: NotRequired[builtins.str]
+    result: Required[Literal['authentic', 'ai_generated', 'ai_modified', 'inconclusive']]
+    confidence: NotRequired[builtins.float]
+    details_url: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceEmbeddedProvenanceItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceWatermarksItemVerifyAgent(TypedDict, total=False):
+    agent_url: Required[builtins.str]
+    feature_id: NotRequired[builtins.str]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItem(TypedDict, total=False):
+    country: Required[builtins.str]
+    region: NotRequired[builtins.str]
+    regulation: Required[builtins.str]
+    label_text: NotRequired[builtins.str]
+    render_guidance: NotRequired[_TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance]
+
+class _TasksGetRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class _TasksListRequestAccountVariant2BrandBrandKitOverrideLogoProvenanceDisclosureJurisdictionsItemRenderGuidance(TypedDict, total=False):
+    persistence: NotRequired[Literal['continuous', 'initial', 'flexible']]
+    min_duration_ms: NotRequired[builtins.int]
+    positions: NotRequired[builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']]]
+    ext: NotRequired[builtins.dict[builtins.str, Any]]
+
+class AcceptProposalInputRequiredResponse(VersionedSchemaModel):
+    reason: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcceptProposalRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    idempotency_key: builtins.str
+    account: builtins.dict[builtins.str, Any]
+    proposal_id: builtins.str
+    proposal_terms_digest: builtins.str
+    total_budget: _AcceptProposalRequestTotalBudget | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    io_acceptance: _AcceptProposalRequestIoAcceptance | None
+    purchase_order_ref: builtins.str | None
+    governance_context: builtins.str | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    opportunity: _AcceptProposalRequestOpportunity | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: builtins.dict[builtins.str, Any],
+        proposal_id: builtins.str,
+        proposal_terms_digest: builtins.str,
+        adcp_version: builtins.str = ...,
+        total_budget: _AcceptProposalRequestTotalBudget = ...,
+        daily_budget_cap: builtins.float = ...,
+        budget_cap_timezone: builtins.str = ...,
+        io_acceptance: _AcceptProposalRequestIoAcceptance = ...,
+        purchase_order_ref: builtins.str = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        opportunity: _AcceptProposalRequestOpportunity = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcceptProposalSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcceptProposalResponse(VersionedSchemaModel):
+    status: Literal['completed'] | Literal['failed'] | Literal['submitted']
+    media_buy_id: builtins.str | None
+    revision: builtins.int | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    confirmed_at: builtins.str | None
+    accepted_proposal: _AcceptProposalResponseAcceptedProposal | None
+    purchase_bindings: builtins.list[_AcceptProposalResponsePurchaseBindingsItem] | None
+    available_actions: builtins.list[_AcceptProposalResponseAvailableActionsItemVariant1 | _AcceptProposalResponseAvailableActionsItemVariant2 | _AcceptProposalResponseAvailableActionsItemVariant3] | None
+    warnings: builtins.list[_AcceptProposalResponseWarningsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed'],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        accepted_proposal: _AcceptProposalResponseAcceptedProposal,
+        purchase_bindings: builtins.list[_AcceptProposalResponsePurchaseBindingsItem],
+        available_actions: builtins.list[_AcceptProposalResponseAvailableActionsItemVariant1 | _AcceptProposalResponseAvailableActionsItemVariant2 | _AcceptProposalResponseAvailableActionsItemVariant3],
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        confirmed_at: builtins.str | None = ...,
+        warnings: builtins.list[_AcceptProposalResponseWarningsItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['failed'],
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class AcceptProposalWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcquireRightsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    governance_context: builtins.str | None
+    rights_id: builtins.str
+    pricing_option_id: builtins.str
+    buyer: _ExternalCoreBrandRef
+    account: _AcquireRightsRequestAccountVariant1 | _AcquireRightsRequestAccountVariant2 | None
+    campaign: _AcquireRightsRequestCampaign
+    revocation_webhook: _ExternalCorePushNotificationConfig
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        pricing_option_id: builtins.str,
+        buyer: _ExternalCoreBrandRef,
+        campaign: _AcquireRightsRequestCampaign,
+        revocation_webhook: _ExternalCorePushNotificationConfig,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        governance_context: builtins.str = ...,
+        account: _AcquireRightsRequestAccountVariant1 | _AcquireRightsRequestAccountVariant2 = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class AcquireRightsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    rights_id: builtins.str | None
+    rights_status: Literal['acquired'] | Literal['pending_approval'] | Literal['rejected'] | None
+    brand_id: builtins.str | None
+    terms: _ExternalBrandRightsTerms | None
+    generation_credentials: builtins.list[_ExternalCoreGenerationCredential] | None
+    restrictions: builtins.list[builtins.str] | None
+    disclosure: _AcquireRightsResponseDisclosure | None
+    approval_webhook: _ExternalCorePushNotificationConfig | None
+    usage_reporting_url: builtins.str | None
+    rights_constraint: _AcquireRightsResponseRightsConstraint | None
+    ext: builtins.dict[builtins.str, Any] | None
+    detail: builtins.str | None
+    estimated_response_time: builtins.str | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        rights_status: Literal['acquired'],
+        brand_id: builtins.str,
+        terms: _ExternalBrandRightsTerms,
+        generation_credentials: builtins.list[_ExternalCoreGenerationCredential],
+        rights_constraint: _AcquireRightsResponseRightsConstraint,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        restrictions: builtins.list[builtins.str] = ...,
+        disclosure: _AcquireRightsResponseDisclosure = ...,
+        approval_webhook: _ExternalCorePushNotificationConfig = ...,
+        usage_reporting_url: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        rights_status: Literal['pending_approval'],
+        brand_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        detail: builtins.str = ...,
+        estimated_response_time: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        rights_status: Literal['rejected'],
+        brand_id: builtins.str,
+        reason: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ActivateSignalRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    action: Literal['activate', 'deactivate']
+    signal_agent_segment_id: builtins.str
+    destinations: builtins.list[_ActivateSignalRequestDestinationsItemVariant1 | _ActivateSignalRequestDestinationsItemVariant2]
+    pricing_option_id: builtins.str | None
+    governance_context: builtins.str | None
+    account: _ActivateSignalRequestAccountVariant1 | _ActivateSignalRequestAccountVariant2 | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        signal_agent_segment_id: builtins.str,
+        destinations: builtins.list[_ActivateSignalRequestDestinationsItemVariant1 | _ActivateSignalRequestDestinationsItemVariant2],
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        action: Literal['activate', 'deactivate'] = ...,
+        pricing_option_id: builtins.str = ...,
+        governance_context: builtins.str = ...,
+        account: _ActivateSignalRequestAccountVariant1 | _ActivateSignalRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ActivateSignalResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    deployments: builtins.list[_ActivateSignalResponseDeploymentsItemVariant1 | _ActivateSignalResponseDeploymentsItemVariant2] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        deployments: builtins.list[_ActivateSignalResponseDeploymentsItemVariant1 | _ActivateSignalResponseDeploymentsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    governance_context: builtins.str | None
+    message: builtins.str | None
+    creative_manifest: _BuildCreativeRequestCreativeManifestVariant1 | _BuildCreativeRequestCreativeManifestVariant2 | None
+    creative_id: builtins.str | None
+    concept_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    package_id: builtins.str | None
+    target_format_id: _ExternalCoreFormatId | None
+    target_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    target_capability_id: builtins.str | None
+    target_capability_ids: builtins.list[builtins.str] | None
+    transformer_id: builtins.str | None
+    config: builtins.dict[builtins.str, Any] | None
+    refine_from_build_variant_id: builtins.str | None
+    mode: Literal['execute', 'estimate']
+    max_spend: _BuildCreativeRequestMaxSpend | None
+    max_creatives: builtins.int | None
+    signal_conditions: builtins.list[_BuildCreativeRequestSignalConditionsItemVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2 | _BuildCreativeRequestSignalConditionsItemVariant3] | None
+    max_variants: builtins.int
+    variant_axis: _BuildCreativeRequestVariantAxis | None
+    keep_mode: Literal['keep_all', 'keep_one', 'keep_some']
+    selection_strategy: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] | None
+    account: _BuildCreativeRequestAccountVariant1 | _BuildCreativeRequestAccountVariant2 | None
+    brand: _ExternalCoreBrandRef | None
+    quality: Literal['draft', 'production'] | None
+    evaluator: _BuildCreativeRequestEvaluatorVariant1 | _BuildCreativeRequestEvaluatorVariant2 | _BuildCreativeRequestEvaluatorVariant3 | None
+    item_limit: builtins.int | None
+    include_preview: builtins.bool | None
+    preview_inputs: builtins.list[_BuildCreativeRequestPreviewInputsItem] | None
+    preview_quality: Literal['draft', 'production'] | None
+    preview_output_format: Literal['url', 'html']
+    macro_values: builtins.dict[builtins.str, builtins.str] | None
+    idempotency_key: builtins.str
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        governance_context: builtins.str = ...,
+        message: builtins.str = ...,
+        creative_manifest: _BuildCreativeRequestCreativeManifestVariant1 | _BuildCreativeRequestCreativeManifestVariant2 = ...,
+        creative_id: builtins.str = ...,
+        concept_id: builtins.str = ...,
+        media_buy_id: builtins.str = ...,
+        package_id: builtins.str = ...,
+        target_format_id: _ExternalCoreFormatId = ...,
+        target_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        target_capability_id: builtins.str = ...,
+        target_capability_ids: builtins.list[builtins.str] = ...,
+        transformer_id: builtins.str = ...,
+        config: builtins.dict[builtins.str, Any] = ...,
+        refine_from_build_variant_id: builtins.str = ...,
+        mode: Literal['execute', 'estimate'] = ...,
+        max_spend: _BuildCreativeRequestMaxSpend = ...,
+        max_creatives: builtins.int = ...,
+        signal_conditions: builtins.list[_BuildCreativeRequestSignalConditionsItemVariant1 | _BuildCreativeRequestSignalConditionsItemVariant2 | _BuildCreativeRequestSignalConditionsItemVariant3] = ...,
+        max_variants: builtins.int = ...,
+        variant_axis: _BuildCreativeRequestVariantAxis = ...,
+        keep_mode: Literal['keep_all', 'keep_one', 'keep_some'] = ...,
+        selection_strategy: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] = ...,
+        account: _BuildCreativeRequestAccountVariant1 | _BuildCreativeRequestAccountVariant2 = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        quality: Literal['draft', 'production'] = ...,
+        evaluator: _BuildCreativeRequestEvaluatorVariant1 | _BuildCreativeRequestEvaluatorVariant2 | _BuildCreativeRequestEvaluatorVariant3 = ...,
+        item_limit: builtins.int = ...,
+        include_preview: builtins.bool = ...,
+        preview_inputs: builtins.list[_BuildCreativeRequestPreviewInputsItem] = ...,
+        preview_quality: Literal['draft', 'production'] = ...,
+        preview_output_format: Literal['url', 'html'] = ...,
+        macro_values: builtins.dict[builtins.str, builtins.str] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    creative_manifest: _BuildCreativeResponseCreativeManifestVariant1 | _BuildCreativeResponseCreativeManifestVariant2 | None
+    build_variant_id: builtins.str | None
+    recipe_hash: builtins.str | None
+    sandbox: builtins.bool | None
+    expires_at: builtins.str | None
+    preview: _BuildCreativeResponsePreview | _BuildCreativeResponsePreview2 | None
+    preview_error: _ExternalCoreError | None
+    pricing_option_id: builtins.str | None
+    vendor_cost: builtins.float | None
+    currency: builtins.str | None
+    consumption: _ExternalCoreCreativeConsumption | None
+    ext: builtins.dict[builtins.str, Any] | None
+    creative_manifests: builtins.list[_BuildCreativeResponseCreativeManifestsItemVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant2] | None
+    creatives: builtins.list[_BuildCreativeResponseCreativesItem] | None
+    items_total: builtins.int | None
+    items_returned: builtins.int | None
+    leaves_total: builtins.int | None
+    leaves_returned: builtins.int | None
+    keep_mode_applied: Literal['keep_all', 'keep_one', 'keep_some'] | None
+    selection_strategy_applied: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] | None
+    budget_status: Literal['complete', 'capped'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    mode: Literal['estimate'] | None
+    estimate: _BuildCreativeResponseEstimate | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creative_manifest: _BuildCreativeResponseCreativeManifestVariant1 | _BuildCreativeResponseCreativeManifestVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        build_variant_id: builtins.str = ...,
+        recipe_hash: builtins.str = ...,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        preview: _BuildCreativeResponsePreview = ...,
+        preview_error: _ExternalCoreError = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creative_manifests: builtins.list[_BuildCreativeResponseCreativeManifestsItemVariant1 | _BuildCreativeResponseCreativeManifestsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        preview: _BuildCreativeResponsePreview2 = ...,
+        preview_error: _ExternalCoreError = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creatives: builtins.list[_BuildCreativeResponseCreativesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        items_total: builtins.int = ...,
+        items_returned: builtins.int = ...,
+        leaves_total: builtins.int = ...,
+        leaves_returned: builtins.int = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        keep_mode_applied: Literal['keep_all', 'keep_one', 'keep_some'] = ...,
+        selection_strategy_applied: Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] = ...,
+        budget_status: Literal['complete', 'capped'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        mode: Literal['estimate'],
+        estimate: _BuildCreativeResponseEstimate,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuildCreativeWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuyProductsInputRequiredResponse(VersionedSchemaModel):
+    reason: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuyProductsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    idempotency_key: builtins.str
+    account: builtins.dict[builtins.str, Any]
+    brand: _ExternalCoreBrandKey | None
+    advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] | None
+    feed_version: builtins.str
+    pricing_version: builtins.str | None
+    purchases: builtins.list[_ExternalMediaBuyProductPurchase]
+    total_budget: _BuyProductsRequestTotalBudget | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    budget_allocation: _BuyProductsRequestBudgetAllocationVariant1 | _BuyProductsRequestBudgetAllocationVariant2 | None
+    start_time: Literal['asap'] | builtins.str
+    end_time: builtins.str
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    bidding: _ExternalCoreBiddingPolicy | None
+    paused: builtins.bool
+    purchase_order_ref: builtins.str | None
+    agency_estimate_number: builtins.str | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    governance_context: builtins.str | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    opportunity: _BuyProductsRequestOpportunity | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: builtins.dict[builtins.str, Any],
+        feed_version: builtins.str,
+        purchases: builtins.list[_ExternalMediaBuyProductPurchase],
+        start_time: Literal['asap'] | builtins.str,
+        end_time: builtins.str,
+        adcp_version: builtins.str = ...,
+        brand: _ExternalCoreBrandKey = ...,
+        advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] = ...,
+        pricing_version: builtins.str = ...,
+        total_budget: _BuyProductsRequestTotalBudget = ...,
+        daily_budget_cap: builtins.float = ...,
+        budget_cap_timezone: builtins.str = ...,
+        budget_allocation: _BuyProductsRequestBudgetAllocationVariant1 | _BuyProductsRequestBudgetAllocationVariant2 = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bidding: _ExternalCoreBiddingPolicy = ...,
+        paused: builtins.bool = ...,
+        purchase_order_ref: builtins.str = ...,
+        agency_estimate_number: builtins.str = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        opportunity: _BuyProductsRequestOpportunity = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuyProductsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class BuyProductsResponse(VersionedSchemaModel):
+    status: Literal['completed'] | Literal['failed'] | Literal['submitted']
+    media_buy_id: builtins.str | None
+    revision: builtins.int | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    confirmed_at: builtins.str | None
+    accepted_proposal: _BuyProductsResponseAcceptedProposal | None
+    purchase_bindings: builtins.list[_BuyProductsResponsePurchaseBindingsItem] | None
+    available_actions: builtins.list[_BuyProductsResponseAvailableActionsItemVariant1 | _BuyProductsResponseAvailableActionsItemVariant2 | _BuyProductsResponseAvailableActionsItemVariant3] | None
+    warnings: builtins.list[_BuyProductsResponseWarningsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed'],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        accepted_proposal: _BuyProductsResponseAcceptedProposal,
+        purchase_bindings: builtins.list[_BuyProductsResponsePurchaseBindingsItem],
+        available_actions: builtins.list[_BuyProductsResponseAvailableActionsItemVariant1 | _BuyProductsResponseAvailableActionsItemVariant2 | _BuyProductsResponseAvailableActionsItemVariant3],
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        confirmed_at: builtins.str | None = ...,
+        warnings: builtins.list[_BuyProductsResponseWarningsItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['failed'],
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class BuyProductsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CalibrateContentRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    artifact: _ExternalContentStandardsArtifact
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        artifact: _ExternalContentStandardsArtifact,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CalibrateContentResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    verdict: Literal['pass', 'fail'] | None
+    confidence: builtins.float | None
+    explanation: builtins.str | None
+    features: builtins.list[_CalibrateContentResponseFeaturesItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        verdict: Literal['pass', 'fail'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        confidence: builtins.float = ...,
+        explanation: builtins.str = ...,
+        features: builtins.list[_CalibrateContentResponseFeaturesItem] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CheckGovernanceRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    plan_id: builtins.str | None
+    caller: builtins.str
+    purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']
+    target_agent: builtins.str | None
+    proposed_commitment: _CheckGovernanceRequestProposedCommitment | None
+    execution_commitment: _CheckGovernanceRequestExecutionCommitment | None
+    tool: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    proposal: _ExternalCoreCanonicalProposal | None
+    governance_context: builtins.str | None
+    consultation_context: builtins.str | None
+    phase: Literal['purchase', 'modification', 'delivery']
+    planned_delivery: _ExternalCorePlannedDelivery | None
+    delivery_metrics: _CheckGovernanceRequestDeliveryMetrics | None
+    modification_summary: builtins.str | None
+    runtime_attestations: builtins.list[_CheckGovernanceRequestRuntimeAttestationsItem] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        caller: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        plan_id: builtins.str = ...,
+        purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services'] = ...,
+        target_agent: builtins.str = ...,
+        proposed_commitment: _CheckGovernanceRequestProposedCommitment = ...,
+        execution_commitment: _CheckGovernanceRequestExecutionCommitment = ...,
+        tool: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        proposal: _ExternalCoreCanonicalProposal = ...,
+        governance_context: builtins.str = ...,
+        consultation_context: builtins.str = ...,
+        phase: Literal['purchase', 'modification', 'delivery'] = ...,
+        planned_delivery: _ExternalCorePlannedDelivery = ...,
+        delivery_metrics: _CheckGovernanceRequestDeliveryMetrics = ...,
+        modification_summary: builtins.str = ...,
+        runtime_attestations: builtins.list[_CheckGovernanceRequestRuntimeAttestationsItem] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CheckGovernanceResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    check_id: builtins.str
+    verdict: Literal['approved', 'denied', 'conditions']
+    check_type: Literal['intent', 'execution'] | None
+    plan_id: builtins.str | None
+    explanation: builtins.str
+    findings: builtins.list[_CheckGovernanceResponseFindingsItem] | None
+    conditions: builtins.list[_CheckGovernanceResponseConditionsItem] | None
+    consultation_context: builtins.str | None
+    expires_at: builtins.str | None
+    next_check: builtins.str | None
+    delivery_statement: _CheckGovernanceResponseDeliveryStatement | None
+    categories_evaluated: builtins.list[builtins.str] | None
+    policies_evaluated: builtins.list[builtins.str] | None
+    mode: Literal['audit', 'advisory', 'enforce'] | None
+    runtime_attestation_evaluations: builtins.list[_CheckGovernanceResponseRuntimeAttestationEvaluationsItem] | None
+    runtime_attestation_binding_digest: builtins.str | None
+    governance_context: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        check_id: builtins.str,
+        verdict: Literal['approved', 'denied', 'conditions'],
+        explanation: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        check_type: Literal['intent', 'execution'] = ...,
+        plan_id: builtins.str = ...,
+        findings: builtins.list[_CheckGovernanceResponseFindingsItem] = ...,
+        conditions: builtins.list[_CheckGovernanceResponseConditionsItem] = ...,
+        consultation_context: builtins.str = ...,
+        expires_at: builtins.str = ...,
+        next_check: builtins.str = ...,
+        delivery_statement: _CheckGovernanceResponseDeliveryStatement = ...,
+        categories_evaluated: builtins.list[builtins.str] = ...,
+        policies_evaluated: builtins.list[builtins.str] = ...,
+        mode: Literal['audit', 'advisory', 'enforce'] = ...,
+        runtime_attestation_evaluations: builtins.list[_CheckGovernanceResponseRuntimeAttestationEvaluationsItem] = ...,
+        runtime_attestation_binding_digest: builtins.str = ...,
+        governance_context: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ComplyTestControllerRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    scenario: builtins.str
+    params: _ComplyTestControllerRequestParams | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    account: _ComplyTestControllerRequestAccount
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        scenario: builtins.str,
+        account: _ComplyTestControllerRequestAccount,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        params: _ComplyTestControllerRequestParams = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ComplyTestControllerResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    success: Literal[True] | Literal[False]
+    scenarios: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    previous_state: builtins.str | None
+    current_state: builtins.str | builtins.str | None
+    simulated: builtins.dict[builtins.str, Any] | None
+    cumulative: builtins.dict[builtins.str, Any] | None
+    forced: _ComplyTestControllerResponseForced | None
+    creative_id: builtins.str | None
+    audit_observations: builtins.list[_ExternalCreativeAuditObservation] | None
+    recorded_calls: builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant1 | _ComplyTestControllerResponseRecordedCallsItemVariant2] | None
+    total_count: builtins.int | None
+    truncated: builtins.bool | None
+    since_timestamp: builtins.str | None
+    error: Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'JCS_NON_FINITE_NUMBER', 'INTERNAL_ERROR'] | None
+    error_detail: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        scenarios: builtins.list[builtins.str],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        previous_state: builtins.str,
+        current_state: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        simulated: builtins.dict[builtins.str, Any],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        cumulative: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        forced: _ComplyTestControllerResponseForced,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        creative_id: builtins.str,
+        audit_observations: builtins.list[_ExternalCreativeAuditObservation],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        recorded_calls: builtins.list[_ComplyTestControllerResponseRecordedCallsItemVariant1 | _ComplyTestControllerResponseRecordedCallsItemVariant2],
+        total_count: builtins.int,
+        since_timestamp: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        truncated: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[False],
+        error: Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'JCS_NON_FINITE_NUMBER', 'INTERNAL_ERROR'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        error_detail: builtins.str = ...,
+        current_state: builtins.str | None = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ContextMatchRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    type: Literal['context_match_request']
+    protocol_version: builtins.str
+    request_id: builtins.str
+    property_rid: builtins.str
+    property_id: builtins.str | None
+    property_type: Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']
+    placement_id: builtins.str
+    seller_agent_url: builtins.str
+    artifact: _ExternalContentStandardsArtifact | None
+    artifact_refs: builtins.list[_ContextMatchRequestArtifactRefsItem] | None
+    geo: _ContextMatchRequestGeo | None
+    context_signals: _ContextMatchRequestContextSignals | None
+    package_ids: builtins.list[builtins.str] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['context_match_request'],
+        request_id: builtins.str,
+        property_rid: builtins.str,
+        property_type: Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant'],
+        placement_id: builtins.str,
+        seller_agent_url: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        protocol_version: builtins.str = ...,
+        property_id: builtins.str = ...,
+        artifact: _ExternalContentStandardsArtifact = ...,
+        artifact_refs: builtins.list[_ContextMatchRequestArtifactRefsItem] = ...,
+        geo: _ContextMatchRequestGeo = ...,
+        context_signals: _ContextMatchRequestContextSignals = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+    ) -> None: ...
+
+class ContextMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['context_match_response']
+    request_id: builtins.str
+    offers: builtins.list[_ExternalTrustedMatchOffer]
+    signals: _ContextMatchResponseSignals | None
+    signals_by_provider: builtins.dict[builtins.str, _ContextMatchResponseSignalsByProviderValue] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['context_match_response'],
+        request_id: builtins.str,
+        offers: builtins.list[_ExternalTrustedMatchOffer],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        signals: _ContextMatchResponseSignals = ...,
+        signals_by_provider: builtins.dict[builtins.str, _ContextMatchResponseSignalsByProviderValue] = ...,
+    ) -> None: ...
+
+class ControlMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ControlMediaBuyRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    idempotency_key: builtins.str
+    account: builtins.dict[builtins.str, Any]
+    media_buy_id: builtins.str
+    revision: builtins.int
+    paused: builtins.bool | None
+    canceled: Literal[True] | None
+    cancellation_reason: builtins.str | None
+    total_budget: _ControlMediaBuyRequestTotalBudget | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    budget_allocation: _ControlMediaBuyRequestBudgetAllocationVariant1 | _ControlMediaBuyRequestBudgetAllocationVariant2 | None
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    bidding: _ExternalCoreBiddingPolicy | None
+    packages: builtins.list[_ExternalMediaBuyPackageControl] | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    governance_context: builtins.str | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: builtins.dict[builtins.str, Any],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        adcp_version: builtins.str = ...,
+        paused: builtins.bool = ...,
+        canceled: Literal[True] = ...,
+        cancellation_reason: builtins.str = ...,
+        total_budget: _ControlMediaBuyRequestTotalBudget = ...,
+        daily_budget_cap: builtins.float | None = ...,
+        budget_cap_timezone: builtins.str | None = ...,
+        budget_allocation: _ControlMediaBuyRequestBudgetAllocationVariant1 | _ControlMediaBuyRequestBudgetAllocationVariant2 = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bidding: _ExternalCoreBiddingPolicy | None = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageControl] = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ControlMediaBuySubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ControlMediaBuyResponse(VersionedSchemaModel):
+    status: Literal['completed'] | Literal['failed'] | Literal['submitted']
+    media_buy_id: builtins.str | None
+    revision: builtins.int | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    implementation_date: builtins.str | None
+    affected_package_ids: builtins.list[builtins.str] | None
+    available_actions: builtins.list[_ControlMediaBuyResponseAvailableActionsItemVariant1 | _ControlMediaBuyResponseAvailableActionsItemVariant2 | _ControlMediaBuyResponseAvailableActionsItemVariant3] | None
+    warnings: builtins.list[_ControlMediaBuyResponseWarningsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed'],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        implementation_date: builtins.str | None = ...,
+        affected_package_ids: builtins.list[builtins.str] = ...,
+        available_actions: builtins.list[_ControlMediaBuyResponseAvailableActionsItemVariant1 | _ControlMediaBuyResponseAvailableActionsItemVariant2 | _ControlMediaBuyResponseAvailableActionsItemVariant3] = ...,
+        warnings: builtins.list[_ControlMediaBuyResponseWarningsItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['failed'],
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class ControlMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _CreateCollectionListRequestAccountVariant1 | _CreateCollectionListRequestAccountVariant2 | None
+    name: builtins.str
+    description: builtins.str | None
+    base_collections: builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1 | _CreateCollectionListRequestBaseCollectionsItemVariant2 | _CreateCollectionListRequestBaseCollectionsItemVariant3] | None
+    filters: _ExternalCollectionCollectionListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _CreateCollectionListRequestAccountVariant1 | _CreateCollectionListRequestAccountVariant2 = ...,
+        description: builtins.str = ...,
+        base_collections: builtins.list[_CreateCollectionListRequestBaseCollectionsItemVariant1 | _CreateCollectionListRequestBaseCollectionsItemVariant2 | _CreateCollectionListRequestBaseCollectionsItemVariant3] = ...,
+        filters: _ExternalCollectionCollectionListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalCollectionCollectionList
+    auth_token: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalCollectionCollectionList,
+        auth_token: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    scope: _CreateContentStandardsRequestScope
+    registry_policy_ids: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _CreateContentStandardsRequestCalibrationExemplars | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        scope: _CreateContentStandardsRequestScope,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        registry_policy_ids: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _CreateContentStandardsRequestCalibrationExemplars = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    standards_id: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    conflicting_standards_id: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        conflicting_standards_id: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    governance_context: builtins.str | None
+    idempotency_key: builtins.str
+    plan_id: builtins.str | None
+    account: _CreateMediaBuyRequestAccountVariant1 | _CreateMediaBuyRequestAccountVariant2
+    proposal_id: builtins.str | None
+    opportunity: _CreateMediaBuyRequestOpportunity | None
+    total_budget: _CreateMediaBuyRequestTotalBudget | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    budget_allocation: _CreateMediaBuyRequestBudgetAllocationVariant1 | _CreateMediaBuyRequestBudgetAllocationVariant2 | None
+    packages: builtins.list[_ExternalMediaBuyPackageRequest] | None
+    brand: _ExternalCoreBrandRef
+    advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    io_acceptance: _CreateMediaBuyRequestIoAcceptance | None
+    po_number: builtins.str | None
+    name: builtins.str | None
+    agency_estimate_number: builtins.str | None
+    start_time: Literal['asap'] | builtins.str
+    end_time: builtins.str
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    bidding: _CreateMediaBuyRequestBidding | None
+    paused: builtins.bool
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    artifact_webhook: _CreateMediaBuyRequestArtifactWebhook | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _CreateMediaBuyRequestAccountVariant1 | _CreateMediaBuyRequestAccountVariant2,
+        brand: _ExternalCoreBrandRef,
+        start_time: Literal['asap'] | builtins.str,
+        end_time: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        governance_context: builtins.str = ...,
+        plan_id: builtins.str = ...,
+        proposal_id: builtins.str = ...,
+        opportunity: _CreateMediaBuyRequestOpportunity = ...,
+        total_budget: _CreateMediaBuyRequestTotalBudget = ...,
+        daily_budget_cap: builtins.float = ...,
+        budget_cap_timezone: builtins.str = ...,
+        budget_allocation: _CreateMediaBuyRequestBudgetAllocationVariant1 | _CreateMediaBuyRequestBudgetAllocationVariant2 = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageRequest] = ...,
+        advertiser_industry: Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        io_acceptance: _CreateMediaBuyRequestIoAcceptance = ...,
+        po_number: builtins.str = ...,
+        name: builtins.str = ...,
+        agency_estimate_number: builtins.str = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bidding: _CreateMediaBuyRequestBidding = ...,
+        paused: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        artifact_webhook: _CreateMediaBuyRequestArtifactWebhook = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuySubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    proposal_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    name: builtins.str | None
+    account: _ExternalCoreAccount | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    confirmed_at: builtins.str | None
+    creative_deadline: builtins.str | None
+    revision: builtins.int | None
+    currency: builtins.str | None
+    total_budget: builtins.float | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    budget_allocation: _CreateMediaBuyResponseBudgetAllocationVariant1 | _CreateMediaBuyResponseBudgetAllocationVariant2 | None
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    bidding: _CreateMediaBuyResponseBidding | None
+    valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | None
+    available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] | None
+    packages: builtins.list[_ExternalCorePackage] | None
+    planned_delivery: _ExternalCorePlannedDelivery | None
+    warnings: builtins.list[_ExternalCoreWarning] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        media_buy_id: builtins.str,
+        confirmed_at: builtins.str | None,
+        revision: builtins.int,
+        packages: builtins.list[_ExternalCorePackage],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        proposal_id: builtins.str = ...,
+        name: builtins.str = ...,
+        account: _ExternalCoreAccount = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        creative_deadline: builtins.str = ...,
+        currency: builtins.str = ...,
+        total_budget: builtins.float = ...,
+        daily_budget_cap: builtins.float = ...,
+        budget_cap_timezone: builtins.str = ...,
+        budget_allocation: _CreateMediaBuyResponseBudgetAllocationVariant1 | _CreateMediaBuyResponseBudgetAllocationVariant2 = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bidding: _CreateMediaBuyResponseBidding = ...,
+        valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] = ...,
+        available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] = ...,
+        planned_delivery: _ExternalCorePlannedDelivery = ...,
+        warnings: builtins.list[_ExternalCoreWarning] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreateMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreatePropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _CreatePropertyListRequestAccountVariant1 | _CreatePropertyListRequestAccountVariant2 | None
+    name: builtins.str
+    description: builtins.str | None
+    base_properties: builtins.list[_CreatePropertyListRequestBasePropertiesItemVariant1 | _CreatePropertyListRequestBasePropertiesItemVariant2 | _CreatePropertyListRequestBasePropertiesItemVariant3] | None
+    filters: _ExternalPropertyPropertyListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _CreatePropertyListRequestAccountVariant1 | _CreatePropertyListRequestAccountVariant2 = ...,
+        description: builtins.str = ...,
+        base_properties: builtins.list[_CreatePropertyListRequestBasePropertiesItemVariant1 | _CreatePropertyListRequestBasePropertiesItemVariant2 | _CreatePropertyListRequestBasePropertiesItemVariant3] = ...,
+        filters: _ExternalPropertyPropertyListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreatePropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalPropertyPropertyList
+    auth_token: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalPropertyPropertyList,
+        auth_token: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreativeApprovalRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    rights_id: builtins.str
+    creative_id: builtins.str | None
+    creative_url: builtins.str
+    creative_format: _ExternalCoreFormatId | None
+    description: builtins.str | None
+    metadata: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        creative_url: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        creative_id: builtins.str = ...,
+        creative_format: _ExternalCoreFormatId = ...,
+        description: builtins.str = ...,
+        metadata: builtins.dict[builtins.str, Any] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class CreativeApprovalResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    approval_status: Literal['approved'] | Literal['rejected'] | Literal['pending_review'] | None
+    rights_id: builtins.str | None
+    creative_id: builtins.str | None
+    creative_url: builtins.str | None
+    approved_at: builtins.str | None
+    conditions: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    estimated_response_time: builtins.str | None
+    status_url: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        approval_status: Literal['approved'],
+        rights_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        approved_at: builtins.str = ...,
+        conditions: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        approval_status: Literal['rejected'],
+        rights_id: builtins.str,
+        reason: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        approval_status: Literal['pending_review'],
+        rights_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        creative_url: builtins.str = ...,
+        estimated_response_time: builtins.str = ...,
+        status_url: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeclineProposalsInputRequiredResponse(VersionedSchemaModel):
+    reason: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeclineProposalsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    governance_context: builtins.str | None
+    push_notification_config: _DeclineProposalsRequestPushNotificationConfig | None
+    idempotency_key: builtins.str
+    declines: builtins.list[_ExternalMediaBuyProposalDecline]
+    opportunity: _ExternalCoreOpportunityContext | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        declines: builtins.list[_ExternalMediaBuyProposalDecline],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _DeclineProposalsRequestPushNotificationConfig = ...,
+        opportunity: _ExternalCoreOpportunityContext = ...,
+    ) -> None: ...
+
+class DeclineProposalsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeclineProposalsResponse(VersionedSchemaModel):
+    results: builtins.list[_DeclineProposalsResponseResultsItemVariant1 | _DeclineProposalsResponseResultsItemVariant2] | None
+    status: Literal['submitted'] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        results: builtins.list[_DeclineProposalsResponseResultsItemVariant1 | _DeclineProposalsResponseResultsItemVariant2] = ...,
+        status: Literal['submitted'] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class DeclineProposalsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeleteCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _DeleteCollectionListRequestAccountVariant1 | _DeleteCollectionListRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _DeleteCollectionListRequestAccountVariant1 | _DeleteCollectionListRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeleteCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    deleted: builtins.bool
+    list_id: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        deleted: builtins.bool,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeletePropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _DeletePropertyListRequestAccountVariant1 | _DeletePropertyListRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _DeletePropertyListRequestAccountVariant1 | _DeletePropertyListRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class DeletePropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    deleted: builtins.bool
+    list_id: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        deleted: builtins.bool,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAccountFinancialsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetAccountFinancialsRequestAccountVariant1 | _GetAccountFinancialsRequestAccountVariant2
+    period: _ExternalCoreDateRange | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _GetAccountFinancialsRequestAccountVariant1 | _GetAccountFinancialsRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        period: _ExternalCoreDateRange = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAccountFinancialsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    account: _GetAccountFinancialsResponseAccountVariant1 | _GetAccountFinancialsResponseAccountVariant2 | None
+    currency: builtins.str | None
+    period: _ExternalCoreDateRange | None
+    timezone: builtins.str | None
+    spend: _GetAccountFinancialsResponseSpend | None
+    credit: _GetAccountFinancialsResponseCredit | None
+    balance: _GetAccountFinancialsResponseBalance | None
+    payment_status: Literal['current', 'past_due', 'suspended'] | None
+    payment_terms: Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] | None
+    invoices: builtins.list[_GetAccountFinancialsResponseInvoicesItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        account: _GetAccountFinancialsResponseAccountVariant1 | _GetAccountFinancialsResponseAccountVariant2,
+        currency: builtins.str,
+        period: _ExternalCoreDateRange,
+        timezone: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        spend: _GetAccountFinancialsResponseSpend = ...,
+        credit: _GetAccountFinancialsResponseCredit = ...,
+        balance: _GetAccountFinancialsResponseBalance = ...,
+        payment_status: Literal['current', 'past_due', 'suspended'] = ...,
+        payment_terms: Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] = ...,
+        invoices: builtins.list[_GetAccountFinancialsResponseInvoicesItem] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAdcpCapabilitiesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetAdcpCapabilitiesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    adcp: _GetAdcpCapabilitiesResponseAdcp
+    supported_protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand', 'measurement']]
+    account: _GetAdcpCapabilitiesResponseAccount | None
+    media_buy: _GetAdcpCapabilitiesResponseMediaBuy | None
+    signals: _GetAdcpCapabilitiesResponseSignals | None
+    governance: _GetAdcpCapabilitiesResponseGovernance | None
+    sponsored_intelligence: _GetAdcpCapabilitiesResponseSponsoredIntelligence | None
+    brand: _GetAdcpCapabilitiesResponseBrand | None
+    creative: _GetAdcpCapabilitiesResponseCreative | None
+    oauth: _GetAdcpCapabilitiesResponseOauth | None
+    request_signing: _GetAdcpCapabilitiesResponseRequestSigning | None
+    webhook_signing: _GetAdcpCapabilitiesResponseWebhookSigning | None
+    identity: _GetAdcpCapabilitiesResponseIdentity | None
+    measurement_gateway: _GetAdcpCapabilitiesResponseMeasurementGateway | None
+    measurement: _GetAdcpCapabilitiesResponseMeasurement | None
+    compliance_testing: _GetAdcpCapabilitiesResponseComplianceTesting | None
+    specialisms: builtins.list[Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'creative-transformers', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests', 'sponsored-intelligence']] | None
+    extensions_supported: builtins.list[builtins.str] | None
+    experimental_features: builtins.list[builtins.str] | None
+    wholesale_feed_versioning: _GetAdcpCapabilitiesResponseWholesaleFeedVersioning | None
+    last_updated: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    wholesale_feed_webhooks: _GetAdcpCapabilitiesResponseWholesaleFeedWebhooks | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        adcp: _GetAdcpCapabilitiesResponseAdcp,
+        supported_protocols: builtins.list[Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand', 'measurement']],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        account: _GetAdcpCapabilitiesResponseAccount = ...,
+        media_buy: _GetAdcpCapabilitiesResponseMediaBuy = ...,
+        signals: _GetAdcpCapabilitiesResponseSignals = ...,
+        governance: _GetAdcpCapabilitiesResponseGovernance = ...,
+        sponsored_intelligence: _GetAdcpCapabilitiesResponseSponsoredIntelligence = ...,
+        brand: _GetAdcpCapabilitiesResponseBrand = ...,
+        creative: _GetAdcpCapabilitiesResponseCreative = ...,
+        oauth: _GetAdcpCapabilitiesResponseOauth = ...,
+        request_signing: _GetAdcpCapabilitiesResponseRequestSigning = ...,
+        webhook_signing: _GetAdcpCapabilitiesResponseWebhookSigning = ...,
+        identity: _GetAdcpCapabilitiesResponseIdentity = ...,
+        measurement_gateway: _GetAdcpCapabilitiesResponseMeasurementGateway = ...,
+        measurement: _GetAdcpCapabilitiesResponseMeasurement = ...,
+        compliance_testing: _GetAdcpCapabilitiesResponseComplianceTesting = ...,
+        specialisms: builtins.list[Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'creative-transformers', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests', 'sponsored-intelligence']] = ...,
+        extensions_supported: builtins.list[builtins.str] = ...,
+        experimental_features: builtins.list[builtins.str] = ...,
+        wholesale_feed_versioning: _GetAdcpCapabilitiesResponseWholesaleFeedVersioning = ...,
+        last_updated: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        wholesale_feed_webhooks: _GetAdcpCapabilitiesResponseWholesaleFeedWebhooks = ...,
+    ) -> None: ...
+
+class GetBrandIdentityRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    brand_id: builtins.str
+    fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
+    use_case: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        brand_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] = ...,
+        use_case: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetBrandIdentityResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    brand_id: builtins.str | None
+    house: _GetBrandIdentityResponseHouse | None
+    names: builtins.list[builtins.dict[builtins.str, builtins.str]] | None
+    description: builtins.str | None
+    industries: builtins.list[builtins.str] | None
+    keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] | None
+    logos: builtins.list[_GetBrandIdentityResponseLogosItem] | None
+    colors: _GetBrandIdentityResponseColors | None
+    fonts: _GetBrandIdentityResponseFonts | None
+    visual_guidelines: builtins.dict[builtins.str, Any] | None
+    tone: _GetBrandIdentityResponseTone | None
+    tagline: builtins.str | builtins.list[builtins.dict[builtins.str, builtins.str]] | None
+    voice_synthesis: _GetBrandIdentityResponseVoiceSynthesis | None
+    assets: builtins.list[_GetBrandIdentityResponseAssetsItem] | None
+    rights: _GetBrandIdentityResponseRights | None
+    available_fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        brand_id: builtins.str,
+        house: _GetBrandIdentityResponseHouse,
+        names: builtins.list[builtins.dict[builtins.str, builtins.str]],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        description: builtins.str = ...,
+        industries: builtins.list[builtins.str] = ...,
+        keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] = ...,
+        logos: builtins.list[_GetBrandIdentityResponseLogosItem] = ...,
+        colors: _GetBrandIdentityResponseColors = ...,
+        fonts: _GetBrandIdentityResponseFonts = ...,
+        visual_guidelines: builtins.dict[builtins.str, Any] = ...,
+        tone: _GetBrandIdentityResponseTone = ...,
+        tagline: builtins.str | builtins.list[builtins.dict[builtins.str, builtins.str]] = ...,
+        voice_synthesis: _GetBrandIdentityResponseVoiceSynthesis = ...,
+        assets: builtins.list[_GetBrandIdentityResponseAssetsItem] = ...,
+        rights: _GetBrandIdentityResponseRights = ...,
+        available_fields: builtins.list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _GetCollectionListRequestAccountVariant1 | _GetCollectionListRequestAccountVariant2 | None
+    resolve: builtins.bool
+    pagination: _GetCollectionListRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetCollectionListRequestAccountVariant1 | _GetCollectionListRequestAccountVariant2 = ...,
+        resolve: builtins.bool = ...,
+        pagination: _GetCollectionListRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalCollectionCollectionList
+    collections: builtins.list[_GetCollectionListResponseCollectionsItem] | None
+    pagination: _ExternalCorePaginationResponse | None
+    resolved_at: builtins.str | None
+    cache_valid_until: builtins.str | None
+    coverage_gaps: builtins.dict[builtins.str, builtins.list[_GetCollectionListResponseCoverageGapsValueItem]] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalCollectionCollectionList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        collections: builtins.list[_GetCollectionListResponseCollectionsItem] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        resolved_at: builtins.str = ...,
+        cache_valid_until: builtins.str = ...,
+        coverage_gaps: builtins.dict[builtins.str, builtins.list[_GetCollectionListResponseCoverageGapsValueItem]] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    standards_id: builtins.str | None
+    name: builtins.str | None
+    countries_all: builtins.list[builtins.str] | None
+    channels_any: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None
+    languages_any: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _GetContentStandardsResponseCalibrationExemplars | None
+    pricing_options: builtins.list[_GetContentStandardsResponsePricingOptionsItemVariant1 | _GetContentStandardsResponsePricingOptionsItemVariant2 | _GetContentStandardsResponsePricingOptionsItemVariant3 | _GetContentStandardsResponsePricingOptionsItemVariant4 | _GetContentStandardsResponsePricingOptionsItemVariant5] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        name: builtins.str = ...,
+        countries_all: builtins.list[builtins.str] = ...,
+        channels_any: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] = ...,
+        languages_any: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _GetContentStandardsResponseCalibrationExemplars = ...,
+        pricing_options: builtins.list[_GetContentStandardsResponsePricingOptionsItemVariant1 | _GetContentStandardsResponsePricingOptionsItemVariant2 | _GetContentStandardsResponsePricingOptionsItemVariant3 | _GetContentStandardsResponsePricingOptionsItemVariant4 | _GetContentStandardsResponsePricingOptionsItemVariant5] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetCreativeDeliveryRequestAccountVariant1 | _GetCreativeDeliveryRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    creative_ids: builtins.list[builtins.str] | None
+    start_date: builtins.str | None
+    end_date: builtins.str | None
+    max_variants: builtins.int | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetCreativeDeliveryRequestAccountVariant1 | _GetCreativeDeliveryRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        creative_ids: builtins.list[builtins.str] = ...,
+        start_date: builtins.str = ...,
+        end_date: builtins.str = ...,
+        max_variants: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    account_id: builtins.str | None
+    media_buy_id: builtins.str | None
+    currency: builtins.str
+    reporting_period: _GetCreativeDeliveryResponseReportingPeriod
+    creatives: builtins.list[_GetCreativeDeliveryResponseCreativesItem]
+    pagination: _GetCreativeDeliveryResponsePagination | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        currency: builtins.str,
+        reporting_period: _GetCreativeDeliveryResponseReportingPeriod,
+        creatives: builtins.list[_GetCreativeDeliveryResponseCreativesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        account_id: builtins.str = ...,
+        media_buy_id: builtins.str = ...,
+        pagination: _GetCreativeDeliveryResponsePagination = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeFeaturesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    creative_manifest: _GetCreativeFeaturesRequestCreativeManifestVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant2
+    feature_ids: builtins.list[builtins.str] | None
+    account: _GetCreativeFeaturesRequestAccountVariant1 | _GetCreativeFeaturesRequestAccountVariant2 | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        creative_manifest: _GetCreativeFeaturesRequestCreativeManifestVariant1 | _GetCreativeFeaturesRequestCreativeManifestVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        feature_ids: builtins.list[builtins.str] = ...,
+        account: _GetCreativeFeaturesRequestAccountVariant1 | _GetCreativeFeaturesRequestAccountVariant2 = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetCreativeFeaturesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_ExternalCreativeCreativeFeatureResult] | None
+    detail_url: builtins.str | None
+    audit_observations: builtins.list[_ExternalCreativeAuditObservation] | None
+    pricing_option_id: builtins.str | None
+    vendor_cost: builtins.float | None
+    currency: builtins.str | None
+    consumption: _ExternalCoreCreativeConsumption | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        results: builtins.list[_ExternalCreativeCreativeFeatureResult],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        detail_url: builtins.str = ...,
+        audit_observations: builtins.list[_ExternalCreativeAuditObservation] = ...,
+        pricing_option_id: builtins.str = ...,
+        vendor_cost: builtins.float = ...,
+        currency: builtins.str = ...,
+        consumption: _ExternalCoreCreativeConsumption = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyArtifactsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuyArtifactsRequestAccountVariant1 | _GetMediaBuyArtifactsRequestAccountVariant2 | None
+    media_buy_id: builtins.str
+    package_ids: builtins.list[builtins.str] | None
+    failures_only: builtins.bool
+    time_range: _GetMediaBuyArtifactsRequestTimeRange | None
+    pagination: _GetMediaBuyArtifactsRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuyArtifactsRequestAccountVariant1 | _GetMediaBuyArtifactsRequestAccountVariant2 = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+        failures_only: builtins.bool = ...,
+        time_range: _GetMediaBuyArtifactsRequestTimeRange = ...,
+        pagination: _GetMediaBuyArtifactsRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyArtifactsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buy_id: builtins.str | None
+    artifacts: builtins.list[_GetMediaBuyArtifactsResponseArtifactsItem] | None
+    collection_info: _GetMediaBuyArtifactsResponseCollectionInfo | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        media_buy_id: builtins.str,
+        artifacts: builtins.list[_GetMediaBuyArtifactsResponseArtifactsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        collection_info: _GetMediaBuyArtifactsResponseCollectionInfo = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuyDeliveryRequestAccountVariant1 | _GetMediaBuyDeliveryRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None
+    start_date: builtins.str | None
+    end_date: builtins.str | None
+    include_package_daily_breakdown: builtins.bool
+    time_granularity: Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign'] | None
+    include_window_breakdown: builtins.bool
+    attribution_window: _GetMediaBuyDeliveryRequestAttributionWindow | None
+    reporting_dimensions: _GetMediaBuyDeliveryRequestReportingDimensions | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuyDeliveryRequestAccountVariant1 | _GetMediaBuyDeliveryRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] = ...,
+        start_date: builtins.str = ...,
+        end_date: builtins.str = ...,
+        include_package_daily_breakdown: builtins.bool = ...,
+        time_granularity: Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign'] = ...,
+        include_window_breakdown: builtins.bool = ...,
+        attribution_window: _GetMediaBuyDeliveryRequestAttributionWindow = ...,
+        reporting_dimensions: _GetMediaBuyDeliveryRequestReportingDimensions = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuyDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    notification_type: Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] | None
+    partial_data: builtins.bool | None
+    unavailable_count: builtins.int | None
+    sequence_number: builtins.int | None
+    next_expected_at: builtins.str | None
+    reporting_period: _GetMediaBuyDeliveryResponseReportingPeriod
+    currency: builtins.str
+    attribution_window: _ExternalCoreAttributionWindow | None
+    aggregated_totals: _GetMediaBuyDeliveryResponseAggregatedTotals | None
+    media_buy_deliveries: builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        reporting_period: _GetMediaBuyDeliveryResponseReportingPeriod,
+        currency: builtins.str,
+        media_buy_deliveries: builtins.list[_GetMediaBuyDeliveryResponseMediaBuyDeliveriesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        notification_type: Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] = ...,
+        partial_data: builtins.bool = ...,
+        unavailable_count: builtins.int = ...,
+        sequence_number: builtins.int = ...,
+        next_expected_at: builtins.str = ...,
+        attribution_window: _ExternalCoreAttributionWindow = ...,
+        aggregated_totals: _GetMediaBuyDeliveryResponseAggregatedTotals = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuysRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _GetMediaBuysRequestAccountVariant1 | _GetMediaBuysRequestAccountVariant2 | None
+    media_buy_ids: builtins.list[builtins.str] | None
+    status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None
+    indicator_types: builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']] | None
+    include_snapshot: builtins.bool
+    include_history: builtins.int
+    include_webhook_activity: builtins.bool
+    webhook_activity_limit: builtins.int
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetMediaBuysRequestAccountVariant1 | _GetMediaBuysRequestAccountVariant2 = ...,
+        media_buy_ids: builtins.list[builtins.str] = ...,
+        status_filter: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | builtins.list[Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] = ...,
+        indicator_types: builtins.list[Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']] = ...,
+        include_snapshot: builtins.bool = ...,
+        include_history: builtins.int = ...,
+        include_webhook_activity: builtins.bool = ...,
+        webhook_activity_limit: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetMediaBuysResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buys: builtins.list[_GetMediaBuysResponseMediaBuysItem]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        media_buys: builtins.list[_GetMediaBuysResponseMediaBuysItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPlanAuditLogsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    plan_ids: builtins.list[builtins.str] | None
+    portfolio_plan_ids: builtins.list[builtins.str] | None
+    governance_contexts: builtins.list[builtins.str] | None
+    purchase_types: builtins.list[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] | None
+    include_entries: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        plan_ids: builtins.list[builtins.str] = ...,
+        portfolio_plan_ids: builtins.list[builtins.str] = ...,
+        governance_contexts: builtins.list[builtins.str] = ...,
+        purchase_types: builtins.list[Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] = ...,
+        include_entries: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPlanAuditLogsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    plans: builtins.list[_GetPlanAuditLogsResponsePlansItem]
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        plans: builtins.list[_GetPlanAuditLogsResponsePlansItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] | None
+    partial_results: builtins.list[_ExternalCoreProduct] | None
+    suggestions: builtins.list[builtins.str] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] = ...,
+        partial_results: builtins.list[_ExternalCoreProduct] = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str | None
+    buying_mode: Literal['brief', 'wholesale', 'refine']
+    brief: builtins.str | None
+    refine: builtins.list[_GetProductsRequestRefineItemVariant1 | _GetProductsRequestRefineItemVariant2 | _GetProductsRequestRefineItemVariant3] | None
+    brand: _ExternalCoreBrandRef | None
+    catalog: _ExternalCoreCatalog | None
+    account: _GetProductsRequestAccountVariant1 | _GetProductsRequestAccountVariant2 | None
+    preferred_delivery_types: builtins.list[Literal['guaranteed', 'non_guaranteed']] | None
+    filters: _ExternalCoreProductFilters | None
+    targeting_overlay: _ExternalCoreTargeting | None
+    required_overlay_support: _ExternalCoreTargetingOverlayRequirements | None
+    property_list: _ExternalCorePropertyListRef | None
+    fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_ids', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'included_signals', 'signal_targeting_allowed', 'signal_targeting_options', 'signal_targeting_rules', 'demographic_targeting', 'overlay_support', 'targeting_resolution', 'audience_evidence', 'audience_evidence_selections', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'is_custom', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] | None
+    time_budget: _GetProductsRequestTimeBudget | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    pagination: _ExternalCorePaginationRequest | None
+    if_wholesale_feed_version: builtins.str | None
+    if_pricing_version: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    required_policies: builtins.list[builtins.str] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        buying_mode: Literal['brief', 'wholesale', 'refine'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        idempotency_key: builtins.str = ...,
+        brief: builtins.str = ...,
+        refine: builtins.list[_GetProductsRequestRefineItemVariant1 | _GetProductsRequestRefineItemVariant2 | _GetProductsRequestRefineItemVariant3] = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        catalog: _ExternalCoreCatalog = ...,
+        account: _GetProductsRequestAccountVariant1 | _GetProductsRequestAccountVariant2 = ...,
+        preferred_delivery_types: builtins.list[Literal['guaranteed', 'non_guaranteed']] = ...,
+        filters: _ExternalCoreProductFilters = ...,
+        targeting_overlay: _ExternalCoreTargeting = ...,
+        required_overlay_support: _ExternalCoreTargetingOverlayRequirements = ...,
+        property_list: _ExternalCorePropertyListRef = ...,
+        fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_ids', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'included_signals', 'signal_targeting_allowed', 'signal_targeting_options', 'signal_targeting_rules', 'demographic_targeting', 'overlay_support', 'targeting_resolution', 'audience_evidence', 'audience_evidence_selections', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'is_custom', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] = ...,
+        time_budget: _GetProductsRequestTimeBudget = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        if_wholesale_feed_version: builtins.str = ...,
+        if_pricing_version: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        required_policies: builtins.list[builtins.str] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    estimated_completion: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        estimated_completion: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    products: builtins.list[_ExternalCoreProduct] | None
+    targeting_resolution: _ExternalMediaBuyGetProductsTargetingResolution | None
+    extensions: builtins.dict[builtins.str, Any] | None
+    proposals: builtins.list[_ExternalCoreProposal] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    property_list_applied: builtins.bool | None
+    catalog_applied: builtins.bool | None
+    refinement_applied: builtins.list[_GetProductsResponseRefinementAppliedItemVariant1 | _GetProductsResponseRefinementAppliedItemVariant2 | _GetProductsResponseRefinementAppliedItemVariant3] | None
+    incomplete: builtins.list[_GetProductsResponseIncompleteItem] | None
+    filter_diagnostics: _GetProductsResponseFilterDiagnostics | None
+    pagination: _ExternalCorePaginationResponse | None
+    wholesale_feed_version: builtins.str | None
+    pricing_version: builtins.str | None
+    cache_scope: Literal['public', 'account'] | None
+    unchanged: Literal[True] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        products: builtins.list[_ExternalCoreProduct] = ...,
+        targeting_resolution: _ExternalMediaBuyGetProductsTargetingResolution = ...,
+        extensions: builtins.dict[builtins.str, Any] = ...,
+        proposals: builtins.list[_ExternalCoreProposal] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        reason: builtins.str = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        property_list_applied: builtins.bool = ...,
+        catalog_applied: builtins.bool = ...,
+        refinement_applied: builtins.list[_GetProductsResponseRefinementAppliedItemVariant1 | _GetProductsResponseRefinementAppliedItemVariant2 | _GetProductsResponseRefinementAppliedItemVariant3] = ...,
+        incomplete: builtins.list[_GetProductsResponseIncompleteItem] = ...,
+        filter_diagnostics: _GetProductsResponseFilterDiagnostics = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        wholesale_feed_version: builtins.str = ...,
+        pricing_version: builtins.str = ...,
+        cache_scope: Literal['public', 'account'] = ...,
+        unchanged: Literal[True] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetProductsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _GetPropertyListRequestAccountVariant1 | _GetPropertyListRequestAccountVariant2 | None
+    resolve: builtins.bool
+    pagination: _GetPropertyListRequestPagination | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetPropertyListRequestAccountVariant1 | _GetPropertyListRequestAccountVariant2 = ...,
+        resolve: builtins.bool = ...,
+        pagination: _GetPropertyListRequestPagination = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetPropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalPropertyPropertyList
+    identifiers: builtins.list[_ExternalCoreIdentifier] | None
+    pagination: _ExternalCorePaginationResponse | None
+    resolved_at: builtins.str | None
+    cache_valid_until: builtins.str | None
+    coverage_gaps: builtins.dict[builtins.str, builtins.list[_ExternalCoreIdentifier]] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalPropertyPropertyList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        identifiers: builtins.list[_ExternalCoreIdentifier] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        resolved_at: builtins.str = ...,
+        cache_valid_until: builtins.str = ...,
+        coverage_gaps: builtins.dict[builtins.str, builtins.list[_ExternalCoreIdentifier]] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetRightsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    query: builtins.str
+    uses: builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]
+    buyer_brand: _ExternalCoreBrandRef | None
+    countries: builtins.list[builtins.str] | None
+    brand_id: builtins.str | None
+    right_type: Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] | None
+    include_excluded: builtins.bool
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query: builtins.str,
+        uses: builtins.list[Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        buyer_brand: _ExternalCoreBrandRef = ...,
+        countries: builtins.list[builtins.str] = ...,
+        brand_id: builtins.str = ...,
+        right_type: Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] = ...,
+        include_excluded: builtins.bool = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetRightsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    rights: builtins.list[_GetRightsResponseRightsItem] | None
+    excluded: builtins.list[_GetRightsResponseExcludedItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights: builtins.list[_GetRightsResponseRightsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        excluded: builtins.list[_GetRightsResponseExcludedItem] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    discovery_mode: Literal['brief', 'wholesale']
+    account: _GetSignalsRequestAccountVariant1 | _GetSignalsRequestAccountVariant2 | None
+    signal_spec: builtins.str | None
+    signal_refs: builtins.list[_GetSignalsRequestSignalRefsItemVariant1 | _GetSignalsRequestSignalRefsItemVariant2 | _GetSignalsRequestSignalRefsItemVariant3] | None
+    signal_ids: builtins.list[_GetSignalsRequestSignalIdsItemVariant1 | _GetSignalsRequestSignalIdsItemVariant2] | None
+    destinations: builtins.list[_GetSignalsRequestDestinationsItemVariant1 | _GetSignalsRequestDestinationsItemVariant2] | None
+    countries: builtins.list[builtins.str] | None
+    filters: _ExternalCoreSignalFilters | None
+    fields: builtins.list[Literal['signal_ref', 'signal_id', 'signal_agent_segment_id', 'name', 'description', 'value_type', 'categories', 'range', 'demographic_predicate', 'signal_type', 'data_provider', 'coverage_percentage', 'deployments', 'pricing_options', 'taxonomy', 'data_sources', 'methodology', 'segmentation_criteria', 'criteria_url', 'refresh_cadence', 'lookback_window', 'onboarder', 'modeling', 'audience_expansion', 'device_expansion', 'countries', 'consent_basis', 'restricted_attributes', 'policy_categories', 'art9_basis', 'data_subject_rights', 'last_updated']] | None
+    max_results: builtins.int | None
+    pagination: _ExternalCorePaginationRequest | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    if_wholesale_feed_version: builtins.str | None
+    if_pricing_version: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        discovery_mode: Literal['brief', 'wholesale'] = ...,
+        account: _GetSignalsRequestAccountVariant1 | _GetSignalsRequestAccountVariant2 = ...,
+        signal_spec: builtins.str = ...,
+        signal_refs: builtins.list[_GetSignalsRequestSignalRefsItemVariant1 | _GetSignalsRequestSignalRefsItemVariant2 | _GetSignalsRequestSignalRefsItemVariant3] = ...,
+        signal_ids: builtins.list[_GetSignalsRequestSignalIdsItemVariant1 | _GetSignalsRequestSignalIdsItemVariant2] = ...,
+        destinations: builtins.list[_GetSignalsRequestDestinationsItemVariant1 | _GetSignalsRequestDestinationsItemVariant2] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        filters: _ExternalCoreSignalFilters = ...,
+        fields: builtins.list[Literal['signal_ref', 'signal_id', 'signal_agent_segment_id', 'name', 'description', 'value_type', 'categories', 'range', 'demographic_predicate', 'signal_type', 'data_provider', 'coverage_percentage', 'deployments', 'pricing_options', 'taxonomy', 'data_sources', 'methodology', 'segmentation_criteria', 'criteria_url', 'refresh_cadence', 'lookback_window', 'onboarder', 'modeling', 'audience_expansion', 'device_expansion', 'countries', 'consent_basis', 'restricted_attributes', 'policy_categories', 'art9_basis', 'data_subject_rights', 'last_updated']] = ...,
+        max_results: builtins.int = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        if_wholesale_feed_version: builtins.str = ...,
+        if_pricing_version: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    estimated_completion: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        estimated_completion: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    signals: builtins.list[_GetSignalsResponseSignalsItem] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    incomplete: builtins.list[_GetSignalsResponseIncompleteItem] | None
+    wholesale_feed_version: builtins.str | None
+    pricing_version: builtins.str | None
+    cache_scope: Literal['public', 'account'] | None
+    unchanged: Literal[True] | None
+    pagination: _ExternalCorePaginationResponse | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        signals: builtins.list[_GetSignalsResponseSignalsItem] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        incomplete: builtins.list[_GetSignalsResponseIncompleteItem] = ...,
+        wholesale_feed_version: builtins.str = ...,
+        pricing_version: builtins.str = ...,
+        cache_scope: Literal['public', 'account'] = ...,
+        unchanged: Literal[True] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetSignalsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetTaskStatusRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    task_id: builtins.str
+    account: _GetTaskStatusRequestAccountVariant1 | _GetTaskStatusRequestAccountVariant2 | None
+    include_history: builtins.bool
+    include_result: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _GetTaskStatusRequestAccountVariant1 | _GetTaskStatusRequestAccountVariant2 = ...,
+        include_history: builtins.bool = ...,
+        include_result: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class GetTaskStatusResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    task_type: Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']
+    protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']
+    created_at: builtins.str
+    updated_at: builtins.str
+    completed_at: builtins.str | None
+    has_webhook: builtins.bool | None
+    progress: _GetTaskStatusResponseProgress | None
+    error: _GetTaskStatusResponseError | None
+    history: builtins.list[_GetTaskStatusResponseHistoryItem] | None
+    result: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        task_type: Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs'],
+        protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement'],
+        created_at: builtins.str,
+        updated_at: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        completed_at: builtins.str = ...,
+        has_webhook: builtins.bool = ...,
+        progress: _GetTaskStatusResponseProgress = ...,
+        error: _GetTaskStatusResponseError = ...,
+        history: builtins.list[_GetTaskStatusResponseHistoryItem] = ...,
+        result: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class IdentityMatchRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    type: Literal['identity_match_request']
+    protocol_version: builtins.str
+    request_id: builtins.str
+    seller_agent_url: builtins.str
+    identities: builtins.list[_IdentityMatchRequestIdentitiesItem]
+    consent: _IdentityMatchRequestConsent | None
+    package_ids: builtins.list[builtins.str] | None
+    country: builtins.str | None
+    sealed_credentials: builtins.list[_IdentityMatchRequestSealedCredentialsItem] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        type: Literal['identity_match_request'],
+        request_id: builtins.str,
+        seller_agent_url: builtins.str,
+        identities: builtins.list[_IdentityMatchRequestIdentitiesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        protocol_version: builtins.str = ...,
+        consent: _IdentityMatchRequestConsent = ...,
+        package_ids: builtins.list[builtins.str] = ...,
+        country: builtins.str = ...,
+        sealed_credentials: builtins.list[_IdentityMatchRequestSealedCredentialsItem] = ...,
+    ) -> None: ...
+
+class IdentityMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['identity_match_response']
+    request_id: builtins.str
+    eligible_package_ids: builtins.list[builtins.str]
+    serve_window_sec: builtins.int
+    tmpx: builtins.str | None
+    tmpx_providers: builtins.dict[builtins.str, _IdentityMatchResponseTmpxProvidersValue] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['identity_match_response'],
+        request_id: builtins.str,
+        eligible_package_ids: builtins.list[builtins.str],
+        serve_window_sec: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        tmpx: builtins.str = ...,
+        tmpx_providers: builtins.dict[builtins.str, _IdentityMatchResponseTmpxProvidersValue] = ...,
+    ) -> None: ...
+
+class ListAccountsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListAccountsRequestAccountVariant1 | _ListAccountsRequestAccountVariant2 | None
+    status: Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] | None
+    pagination: _ExternalCorePaginationRequest | None
+    sandbox: builtins.bool | None
+    include_webhook_activity: builtins.bool
+    webhook_activity_limit: builtins.int
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListAccountsRequestAccountVariant1 | _ListAccountsRequestAccountVariant2 = ...,
+        status: Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        sandbox: builtins.bool = ...,
+        include_webhook_activity: builtins.bool = ...,
+        webhook_activity_limit: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListAccountsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    accounts: builtins.list[_ExternalCoreAccountWithAuthorization]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accounts: builtins.list[_ExternalCoreAccountWithAuthorization],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCollectionListsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListCollectionListsRequestAccountVariant1 | _ListCollectionListsRequestAccountVariant2 | None
+    name_contains: builtins.str | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListCollectionListsRequestAccountVariant1 | _ListCollectionListsRequestAccountVariant2 = ...,
+        name_contains: builtins.str = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCollectionListsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    lists: builtins.list[_ExternalCollectionCollectionList]
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        lists: builtins.list[_ExternalCollectionCollectionList],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    channels: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None
+    languages: builtins.list[builtins.str] | None
+    countries: builtins.list[builtins.str] | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        channels: builtins.list[Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] = ...,
+        languages: builtins.list[builtins.str] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    standards: builtins.list[_ExternalContentStandardsContentStandards] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        standards: builtins.list[_ExternalContentStandardsContentStandards],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativeFormatsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    format_ids: builtins.list[_ExternalCoreFormatId] | None
+    type: Literal['audio', 'video', 'display', 'dooh'] | None
+    asset_types: builtins.list[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'zip', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']] | None
+    max_width: builtins.int | None
+    max_height: builtins.int | None
+    min_width: builtins.int | None
+    min_height: builtins.int | None
+    is_responsive: builtins.bool | None
+    name_search: builtins.str | None
+    wcag_level: Literal['A', 'AA', 'AAA'] | None
+    disclosure_positions: builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] | None
+    disclosure_persistence: builtins.list[Literal['continuous', 'initial', 'flexible']] | None
+    output_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    input_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    include_pricing: builtins.bool
+    account: _ListCreativeFormatsRequestAccountVariant1 | _ListCreativeFormatsRequestAccountVariant2 | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        type: Literal['audio', 'video', 'display', 'dooh'] = ...,
+        asset_types: builtins.list[Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'zip', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']] = ...,
+        max_width: builtins.int = ...,
+        max_height: builtins.int = ...,
+        min_width: builtins.int = ...,
+        min_height: builtins.int = ...,
+        is_responsive: builtins.bool = ...,
+        name_search: builtins.str = ...,
+        wcag_level: Literal['A', 'AA', 'AAA'] = ...,
+        disclosure_positions: builtins.list[Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] = ...,
+        disclosure_persistence: builtins.list[Literal['continuous', 'initial', 'flexible']] = ...,
+        output_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        input_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        include_pricing: builtins.bool = ...,
+        account: _ListCreativeFormatsRequestAccountVariant1 | _ListCreativeFormatsRequestAccountVariant2 = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativeFormatsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    formats: builtins.list[_ExternalCoreFormat]
+    creative_agents: builtins.list[_ListCreativeFormatsResponseCreativeAgentsItem] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        formats: builtins.list[_ExternalCoreFormat],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_agents: builtins.list[_ListCreativeFormatsResponseCreativeAgentsItem] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    filters: _ExternalCoreCreativeFilters | None
+    sort: _ListCreativesRequestSort | None
+    pagination: _ExternalCorePaginationRequest | None
+    include_assignments: builtins.bool
+    assignment_projection: Literal['all', 'matching']
+    assignment_limit: builtins.int
+    include_snapshot: builtins.bool
+    include_items: builtins.bool
+    include_variables: builtins.bool
+    include_pricing: builtins.bool
+    include_purged: builtins.bool
+    include_webhook_activity: builtins.bool
+    webhook_activity_limit: builtins.int
+    account: _ListCreativesRequestAccountVariant1 | _ListCreativesRequestAccountVariant2 | None
+    fields: builtins.list[Literal['creative_id', 'name', 'format_id', 'format_kind', 'format_option_ref', 'assets', 'status', 'created_date', 'updated_date', 'tags', 'rights', 'rights_attestation_evaluations', 'localization', 'localization_unavailable', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        filters: _ExternalCoreCreativeFilters = ...,
+        sort: _ListCreativesRequestSort = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        include_assignments: builtins.bool = ...,
+        assignment_projection: Literal['all', 'matching'] = ...,
+        assignment_limit: builtins.int = ...,
+        include_snapshot: builtins.bool = ...,
+        include_items: builtins.bool = ...,
+        include_variables: builtins.bool = ...,
+        include_pricing: builtins.bool = ...,
+        include_purged: builtins.bool = ...,
+        include_webhook_activity: builtins.bool = ...,
+        webhook_activity_limit: builtins.int = ...,
+        account: _ListCreativesRequestAccountVariant1 | _ListCreativesRequestAccountVariant2 = ...,
+        fields: builtins.list[Literal['creative_id', 'name', 'format_id', 'format_kind', 'format_option_ref', 'assets', 'status', 'created_date', 'updated_date', 'tags', 'rights', 'rights_attestation_evaluations', 'localization', 'localization_unavailable', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListCreativesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    query_summary: _ListCreativesResponseQuerySummary
+    pagination: _ExternalCorePaginationResponse
+    creatives: builtins.list[_ListCreativesResponseCreativesItemVariant1 | _ListCreativesResponseCreativesItemVariant2]
+    format_summary: builtins.dict[builtins.str, Any] | None
+    status_summary: _ListCreativesResponseStatusSummary | None
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        query_summary: _ListCreativesResponseQuerySummary,
+        pagination: _ExternalCorePaginationResponse,
+        creatives: builtins.list[_ListCreativesResponseCreativesItemVariant1 | _ListCreativesResponseCreativesItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        format_summary: builtins.dict[builtins.str, Any] = ...,
+        status_summary: _ListCreativesResponseStatusSummary = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListProductsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    governance_context: builtins.str | None
+    push_notification_config: _ListProductsRequestPushNotificationConfig | None
+    account: builtins.dict[builtins.str, Any] | None
+    brand: _ExternalCoreBrandKey | None
+    criteria: _ExternalMediaBuyProductDiscoveryCriteria | None
+    fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'reporting_capabilities', 'measurement_terms', 'performance_standards', 'catalog_types', 'signal_targeting_allowed', 'signal_targeting_rules', 'demographic_targeting', 'audience_evidence', 'audience_evidence_selections', 'max_optimization_goals', 'catalog_match', 'brief_relevance', 'expires_at', 'allowed_actions']] | None
+    cursor: builtins.str | None
+    max_results: builtins.int
+    if_feed_version: builtins.str | None
+    if_pricing_version: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        idempotency_key: builtins.str = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _ListProductsRequestPushNotificationConfig = ...,
+        account: builtins.dict[builtins.str, Any] = ...,
+        brand: _ExternalCoreBrandKey = ...,
+        criteria: _ExternalMediaBuyProductDiscoveryCriteria = ...,
+        fields: builtins.list[Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'reporting_capabilities', 'measurement_terms', 'performance_standards', 'catalog_types', 'signal_targeting_allowed', 'signal_targeting_rules', 'demographic_targeting', 'audience_evidence', 'audience_evidence_selections', 'max_optimization_goals', 'catalog_match', 'brief_relevance', 'expires_at', 'allowed_actions']] = ...,
+        cursor: builtins.str = ...,
+        max_results: builtins.int = ...,
+        if_feed_version: builtins.str = ...,
+        if_pricing_version: builtins.str = ...,
+    ) -> None: ...
+
+class ListProductsResponse(VersionedSchemaModel):
+    outcome: Literal['listed'] | Literal['unchanged']
+    products: builtins.list[_ExternalCoreCanonicalProduct] | None
+    next_cursor: builtins.str | None
+    feed_version: builtins.str
+    pricing_version: builtins.str | None
+    cache_scope: Literal['public', 'account']
+    incomplete: builtins.list[_ListProductsResponseIncompleteItem] | None
+    replayed: Literal[True] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        outcome: Literal['listed'],
+        products: builtins.list[_ExternalCoreCanonicalProduct],
+        feed_version: builtins.str,
+        cache_scope: Literal['public', 'account'],
+        next_cursor: builtins.str = ...,
+        pricing_version: builtins.str = ...,
+        incomplete: builtins.list[_ListProductsResponseIncompleteItem] = ...,
+        replayed: Literal[True] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        outcome: Literal['unchanged'],
+        feed_version: builtins.str,
+        cache_scope: Literal['public', 'account'],
+        products: builtins.list[_ExternalCoreCanonicalProduct] = ...,
+        next_cursor: builtins.str = ...,
+        pricing_version: builtins.str = ...,
+        incomplete: builtins.list[_ListProductsResponseIncompleteItem] = ...,
+        replayed: Literal[True] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListPropertyListsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListPropertyListsRequestAccountVariant1 | _ListPropertyListsRequestAccountVariant2 | None
+    name_contains: builtins.str | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListPropertyListsRequestAccountVariant1 | _ListPropertyListsRequestAccountVariant2 = ...,
+        name_contains: builtins.str = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListPropertyListsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    lists: builtins.list[_ExternalPropertyPropertyList]
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        lists: builtins.list[_ExternalPropertyPropertyList],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTasksRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _ListTasksRequestAccountVariant1 | _ListTasksRequestAccountVariant2 | None
+    filters: _ListTasksRequestFilters | None
+    sort: _ListTasksRequestSort | None
+    pagination: _ExternalCorePaginationRequest | None
+    include_history: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ListTasksRequestAccountVariant1 | _ListTasksRequestAccountVariant2 = ...,
+        filters: _ListTasksRequestFilters = ...,
+        sort: _ListTasksRequestSort = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        include_history: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTasksResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    query_summary: _ListTasksResponseQuerySummary
+    tasks: builtins.list[_ListTasksResponseTasksItem]
+    pagination: _ExternalCorePaginationResponse
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        query_summary: _ListTasksResponseQuerySummary,
+        tasks: builtins.list[_ListTasksResponseTasksItem],
+        pagination: _ExternalCorePaginationResponse,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTransformersRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    transformer_ids: builtins.list[builtins.str] | None
+    input_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    output_format_ids: builtins.list[_ExternalCoreFormatId] | None
+    input_format_kinds: builtins.list[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']] | None
+    output_capability_ids: builtins.list[builtins.str] | None
+    name_search: builtins.str | None
+    brief: builtins.str | None
+    expand_params: builtins.list[builtins.str] | None
+    expand_pagination: builtins.list[_ListTransformersRequestExpandPaginationItem] | None
+    include_pricing: builtins.bool
+    account: _ListTransformersRequestAccountVariant1 | _ListTransformersRequestAccountVariant2 | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        transformer_ids: builtins.list[builtins.str] = ...,
+        input_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        output_format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        input_format_kinds: builtins.list[Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom']] = ...,
+        output_capability_ids: builtins.list[builtins.str] = ...,
+        name_search: builtins.str = ...,
+        brief: builtins.str = ...,
+        expand_params: builtins.list[builtins.str] = ...,
+        expand_pagination: builtins.list[_ListTransformersRequestExpandPaginationItem] = ...,
+        include_pricing: builtins.bool = ...,
+        account: _ListTransformersRequestAccountVariant1 | _ListTransformersRequestAccountVariant2 = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ListTransformersResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    transformers: builtins.list[_ExternalCoreTransformer]
+    errors: builtins.list[_ExternalCoreError] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        transformers: builtins.list[_ExternalCoreTransformer],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class LogEventRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    event_source_id: builtins.str
+    test_event_code: builtins.str | None
+    events: builtins.list[_ExternalCoreEvent]
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        event_source_id: builtins.str,
+        events: builtins.list[_ExternalCoreEvent],
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        test_event_code: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class LogEventResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    events_received: builtins.int | None
+    events_processed: builtins.int | None
+    partial_failures: builtins.list[_LogEventResponsePartialFailuresItem] | None
+    warnings: builtins.list[builtins.str] | None
+    match_quality: builtins.float | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        events_received: builtins.int,
+        events_processed: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        partial_failures: builtins.list[_LogEventResponsePartialFailuresItem] = ...,
+        warnings: builtins.list[builtins.str] = ...,
+        match_quality: builtins.float = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class MediaBuyCommitmentResponse(VersionedSchemaModel):
+    status: Literal['completed'] | Literal['failed'] | Literal['submitted']
+    media_buy_id: builtins.str | None
+    revision: builtins.int | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    confirmed_at: builtins.str | None
+    accepted_proposal: _MediaBuyCommitmentResponseAcceptedProposal | None
+    purchase_bindings: builtins.list[_MediaBuyCommitmentResponsePurchaseBindingsItem] | None
+    available_actions: builtins.list[_MediaBuyCommitmentResponseAvailableActionsItemVariant1 | _MediaBuyCommitmentResponseAvailableActionsItemVariant2 | _MediaBuyCommitmentResponseAvailableActionsItemVariant3] | None
+    warnings: builtins.list[_MediaBuyCommitmentResponseWarningsItem] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed'],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        accepted_proposal: _MediaBuyCommitmentResponseAcceptedProposal,
+        purchase_bindings: builtins.list[_MediaBuyCommitmentResponsePurchaseBindingsItem],
+        available_actions: builtins.list[_MediaBuyCommitmentResponseAvailableActionsItemVariant1 | _MediaBuyCommitmentResponseAvailableActionsItemVariant2 | _MediaBuyCommitmentResponseAvailableActionsItemVariant3],
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        confirmed_at: builtins.str | None = ...,
+        warnings: builtins.list[_MediaBuyCommitmentResponseWarningsItem] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['failed'],
+        errors: builtins.list[_ExternalCoreError],
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class PackageRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    product_id: builtins.str
+    format_ids: builtins.list[_ExternalCoreFormatId] | None
+    format_option_refs: builtins.list[_PackageRequestFormatOptionRefsItemVariant1 | _PackageRequestFormatOptionRefsItemVariant2] | None
+    format_kind: Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom'] | None
+    params: builtins.dict[builtins.str, Any] | None
+    budget: builtins.float | None
+    min_spend_target: builtins.float | None
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    pricing_option_id: builtins.str
+    bid_price: builtins.float | None
+    bidding: _PackageRequestBidding | None
+    impressions: builtins.float | None
+    daily_budget_cap: builtins.float | None
+    start_time: builtins.str | None
+    end_time: builtins.str | None
+    paused: builtins.bool
+    catalogs: builtins.list[_ExternalCoreCatalog] | None
+    optimization_goals: builtins.list[_PackageRequestOptimizationGoalsItemVariant1 | _PackageRequestOptimizationGoalsItemVariant2 | _PackageRequestOptimizationGoalsItemVariant3] | None
+    targeting_overlay: _ExternalCoreTargeting | None
+    audience_evidence_requirements: _ExternalCoreAudienceEvidenceRequirements | None
+    audience_evidence_pins: builtins.list[_ExternalCoreAudienceEvidencePin] | None
+    measurement_terms: _ExternalCoreMeasurementTerms | None
+    performance_standards: builtins.list[_ExternalCorePerformanceStandard] | None
+    committed_metrics: builtins.list[_PackageRequestCommittedMetricsItemVariant1 | _PackageRequestCommittedMetricsItemVariant2] | None
+    creative_assignments: builtins.list[_ExternalCoreCreativeAssignment] | None
+    creatives: builtins.list[_PackageRequestCreativesItemVariant1 | _PackageRequestCreativesItemVariant2] | None
+    agency_estimate_number: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        product_id: builtins.str,
+        pricing_option_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        format_ids: builtins.list[_ExternalCoreFormatId] = ...,
+        format_option_refs: builtins.list[_PackageRequestFormatOptionRefsItemVariant1 | _PackageRequestFormatOptionRefsItemVariant2] = ...,
+        format_kind: Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'custom'] = ...,
+        params: builtins.dict[builtins.str, Any] = ...,
+        budget: builtins.float = ...,
+        min_spend_target: builtins.float = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bid_price: builtins.float = ...,
+        bidding: _PackageRequestBidding = ...,
+        impressions: builtins.float = ...,
+        daily_budget_cap: builtins.float = ...,
+        start_time: builtins.str = ...,
+        end_time: builtins.str = ...,
+        paused: builtins.bool = ...,
+        catalogs: builtins.list[_ExternalCoreCatalog] = ...,
+        optimization_goals: builtins.list[_PackageRequestOptimizationGoalsItemVariant1 | _PackageRequestOptimizationGoalsItemVariant2 | _PackageRequestOptimizationGoalsItemVariant3] = ...,
+        targeting_overlay: _ExternalCoreTargeting = ...,
+        audience_evidence_requirements: _ExternalCoreAudienceEvidenceRequirements = ...,
+        audience_evidence_pins: builtins.list[_ExternalCoreAudienceEvidencePin] = ...,
+        measurement_terms: _ExternalCoreMeasurementTerms = ...,
+        performance_standards: builtins.list[_ExternalCorePerformanceStandard] = ...,
+        committed_metrics: builtins.list[_PackageRequestCommittedMetricsItemVariant1 | _PackageRequestCommittedMetricsItemVariant2] = ...,
+        creative_assignments: builtins.list[_ExternalCoreCreativeAssignment] = ...,
+        creatives: builtins.list[_PackageRequestCreativesItemVariant1 | _PackageRequestCreativesItemVariant2] = ...,
+        agency_estimate_number: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PreviewCreativeRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    request_type: Literal['single', 'batch', 'variant']
+    creative_manifest: _PreviewCreativeRequestCreativeManifestVariant1 | _PreviewCreativeRequestCreativeManifestVariant2 | None
+    target_capability_id: builtins.str | None
+    format_id: _ExternalCoreFormatId | None
+    inputs: builtins.list[_PreviewCreativeRequestInputsItem] | None
+    template_id: builtins.str | None
+    quality: Literal['draft', 'production'] | None
+    output_format: Literal['url', 'html']
+    item_limit: builtins.int | None
+    requests: builtins.list[_PreviewCreativeRequestRequestsItem] | None
+    variant_id: builtins.str | None
+    creative_id: builtins.str | None
+    allow_async: builtins.bool
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        request_type: Literal['single', 'batch', 'variant'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        creative_manifest: _PreviewCreativeRequestCreativeManifestVariant1 | _PreviewCreativeRequestCreativeManifestVariant2 = ...,
+        target_capability_id: builtins.str = ...,
+        format_id: _ExternalCoreFormatId = ...,
+        inputs: builtins.list[_PreviewCreativeRequestInputsItem] = ...,
+        template_id: builtins.str = ...,
+        quality: Literal['draft', 'production'] = ...,
+        output_format: Literal['url', 'html'] = ...,
+        item_limit: builtins.int = ...,
+        requests: builtins.list[_PreviewCreativeRequestRequestsItem] = ...,
+        variant_id: builtins.str = ...,
+        creative_id: builtins.str = ...,
+        allow_async: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class PreviewCreativeResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    response_type: Literal['single'] | Literal['batch'] | Literal['variant'] | Literal['submitted']
+    previews: builtins.list[_PreviewCreativeResponsePreviewsItem] | builtins.list[_PreviewCreativeResponsePreviewsItem2] | None
+    quality_used: Literal['draft', 'production'] | None
+    interactive_url: builtins.str | None
+    expires_at: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_PreviewCreativeResponseResultsItemVariant1 | _PreviewCreativeResponseResultsItemVariant2] | None
+    variant_id: builtins.str | None
+    creative_id: builtins.str | None
+    manifest: _PreviewCreativeResponseManifestVariant1 | _PreviewCreativeResponseManifestVariant2 | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        response_type: Literal['single'],
+        previews: builtins.list[_PreviewCreativeResponsePreviewsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        quality_used: Literal['draft', 'production'] = ...,
+        interactive_url: builtins.str = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        response_type: Literal['batch'],
+        results: builtins.list[_PreviewCreativeResponseResultsItemVariant1 | _PreviewCreativeResponseResultsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        response_type: Literal['variant'],
+        variant_id: builtins.str,
+        previews: builtins.list[_PreviewCreativeResponsePreviewsItem2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        creative_id: builtins.str = ...,
+        manifest: _PreviewCreativeResponseManifestVariant1 | _PreviewCreativeResponseManifestVariant2 = ...,
+        expires_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        response_type: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProvidePerformanceFeedbackRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    media_buy_id: builtins.str
+    package_id: builtins.str | None
+    creative_id: builtins.str | None
+    measurement_period: _ExternalCoreDatetimeRange
+    performance_index: builtins.float
+    baseline: Literal['campaign_target', 'control_group', 'seller_history', 'buyer_portfolio', 'market_benchmark', 'other'] | None
+    metric: _ProvidePerformanceFeedbackRequestMetricVariant1 | _ProvidePerformanceFeedbackRequestMetricVariant2 | None
+    metric_type: Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency'] | None
+    producer: _ExternalCoreBrandRef | None
+    vendor: _ExternalCoreBrandRef | None
+    feedback_source: Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner'] | None
+    methodology: builtins.str | None
+    methodology_version: builtins.str | None
+    study_ref: builtins.str | None
+    evidence: _ProvidePerformanceFeedbackRequestEvidence | None
+    evidence_ref: builtins.str | None
+    as_of: builtins.str | None
+    final: builtins.bool | None
+    supersedes_feedback_id: builtins.str | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        media_buy_id: builtins.str,
+        measurement_period: _ExternalCoreDatetimeRange,
+        performance_index: builtins.float,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        package_id: builtins.str = ...,
+        creative_id: builtins.str = ...,
+        baseline: Literal['campaign_target', 'control_group', 'seller_history', 'buyer_portfolio', 'market_benchmark', 'other'] = ...,
+        metric: _ProvidePerformanceFeedbackRequestMetricVariant1 | _ProvidePerformanceFeedbackRequestMetricVariant2 = ...,
+        metric_type: Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency'] = ...,
+        producer: _ExternalCoreBrandRef = ...,
+        vendor: _ExternalCoreBrandRef = ...,
+        feedback_source: Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner'] = ...,
+        methodology: builtins.str = ...,
+        methodology_version: builtins.str = ...,
+        study_ref: builtins.str = ...,
+        evidence: _ProvidePerformanceFeedbackRequestEvidence = ...,
+        evidence_ref: builtins.str = ...,
+        as_of: builtins.str = ...,
+        final: builtins.bool = ...,
+        supersedes_feedback_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProvidePerformanceFeedbackResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    success: Literal[True] | None
+    feedback_id: builtins.str | None
+    application_status: Literal['accepted', 'applied', 'not_applied'] | None
+    status_reason: builtins.str | None
+    received_at: builtins.str | None
+    applied_at: builtins.str | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        feedback_id: builtins.str = ...,
+        application_status: Literal['accepted', 'applied', 'not_applied'] = ...,
+        status_reason: builtins.str = ...,
+        received_at: builtins.str = ...,
+        applied_at: builtins.str = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ProviderContextMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['context_match_response']
+    request_id: builtins.str
+    offers: builtins.list[_ExternalTrustedMatchOffer]
+    cache_ttl: builtins.int | None
+    signals: _ProviderContextMatchResponseSignals | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['context_match_response'],
+        request_id: builtins.str,
+        offers: builtins.list[_ExternalTrustedMatchOffer],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        cache_ttl: builtins.int = ...,
+        signals: _ProviderContextMatchResponseSignals = ...,
+    ) -> None: ...
+
+class ProviderIdentityMatchResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    type: Literal['identity_match_response']
+    request_id: builtins.str
+    eligible_package_ids: builtins.list[builtins.str]
+    serve_window_sec: builtins.int
+    tmpx_chunks: builtins.list[_ExternalTrustedMatchTmpxChunk] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        type: Literal['identity_match_response'],
+        request_id: builtins.str,
+        eligible_package_ids: builtins.list[builtins.str],
+        serve_window_sec: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        tmpx_chunks: builtins.list[_ExternalTrustedMatchTmpxChunk] = ...,
+    ) -> None: ...
+
+class RefineProposalsInputRequiredResponse(VersionedSchemaModel):
+    reason: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class RefineProposalsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    governance_context: builtins.str | None
+    push_notification_config: _RefineProposalsRequestPushNotificationConfig | None
+    idempotency_key: builtins.str
+    refinements: builtins.list[_RefineProposalsRequestRefinementsItemVariant1 | _RefineProposalsRequestRefinementsItemVariant2]
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        refinements: builtins.list[_RefineProposalsRequestRefinementsItemVariant1 | _RefineProposalsRequestRefinementsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _RefineProposalsRequestPushNotificationConfig = ...,
+    ) -> None: ...
+
+class RefineProposalsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class RefineProposalsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    results: builtins.list[_RefineProposalsResponseResultsItemVariant1 | _RefineProposalsResponseResultsItemVariant2 | _RefineProposalsResponseResultsItemVariant3 | _RefineProposalsResponseResultsItemVariant4] | None
+    products: builtins.list[_ExternalCoreCanonicalProduct] | None
+    status: Literal['completed', 'submitted'] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        results: builtins.list[_RefineProposalsResponseResultsItemVariant1 | _RefineProposalsResponseResultsItemVariant2 | _RefineProposalsResponseResultsItemVariant3 | _RefineProposalsResponseResultsItemVariant4] = ...,
+        products: builtins.list[_ExternalCoreCanonicalProduct] = ...,
+        status: Literal['completed', 'submitted'] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class RefineProposalsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanAdjustmentRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    action: Literal['report', 'review']
+    plan_id: builtins.str
+    outcome_id: builtins.str | None
+    adjustment_id: builtins.str | None
+    decision: Literal['accept', 'dispute'] | None
+    seller_reference: builtins.str | None
+    seller_adjustment_id: builtins.str | None
+    adjustment_type: Literal['decommitment', 'refund', 'credit', 'makegood'] | None
+    amount: _ReportPlanAdjustmentRequestAmount | None
+    reason: builtins.str | None
+    effective_at: builtins.str | None
+    evidence: _ReportPlanAdjustmentRequestEvidence | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        action: Literal['report', 'review'],
+        plan_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        outcome_id: builtins.str = ...,
+        adjustment_id: builtins.str = ...,
+        decision: Literal['accept', 'dispute'] = ...,
+        seller_reference: builtins.str = ...,
+        seller_adjustment_id: builtins.str = ...,
+        adjustment_type: Literal['decommitment', 'refund', 'credit', 'makegood'] = ...,
+        amount: _ReportPlanAdjustmentRequestAmount = ...,
+        reason: builtins.str = ...,
+        effective_at: builtins.str = ...,
+        evidence: _ReportPlanAdjustmentRequestEvidence = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanAdjustmentResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    adjustment_id: builtins.str
+    adjustment_state: Literal['reported', 'verified', 'disputed']
+    adjustment_type: Literal['decommitment', 'refund', 'credit', 'makegood']
+    amount: _ReportPlanAdjustmentResponseAmount
+    headroom_restored: builtins.float
+    plan_summary: _ReportPlanAdjustmentResponsePlanSummary
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adjustment_id: builtins.str,
+        adjustment_state: Literal['reported', 'verified', 'disputed'],
+        adjustment_type: Literal['decommitment', 'refund', 'credit', 'makegood'],
+        amount: _ReportPlanAdjustmentResponseAmount,
+        headroom_restored: builtins.float,
+        plan_summary: _ReportPlanAdjustmentResponsePlanSummary,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanOutcomeRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    plan_id: builtins.str
+    check_id: builtins.str | None
+    idempotency_key: builtins.str
+    purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']
+    outcome: Literal['completed', 'failed', 'delivery']
+    seller_response: _ReportPlanOutcomeRequestSellerResponse | None
+    delivery: _ReportPlanOutcomeRequestDelivery | None
+    error: _ReportPlanOutcomeRequestError | None
+    governance_context: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        plan_id: builtins.str,
+        idempotency_key: builtins.str,
+        outcome: Literal['completed', 'failed', 'delivery'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        check_id: builtins.str = ...,
+        purchase_type: Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services'] = ...,
+        seller_response: _ReportPlanOutcomeRequestSellerResponse = ...,
+        delivery: _ReportPlanOutcomeRequestDelivery = ...,
+        error: _ReportPlanOutcomeRequestError = ...,
+        governance_context: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportPlanOutcomeResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    outcome_id: builtins.str
+    outcome_state: Literal['accepted', 'findings']
+    committed_budget: builtins.float | None
+    delivery_reconciliation_status: Literal['consistent', 'measurement_variance', 'disputed', 'unmatched', 'closed_unresolved'] | None
+    delivery_period_state: Literal['open', 'closed'] | None
+    findings: builtins.list[_ReportPlanOutcomeResponseFindingsItem] | None
+    plan_summary: _ReportPlanOutcomeResponsePlanSummary | None
+    replayed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        outcome_id: builtins.str,
+        outcome_state: Literal['accepted', 'findings'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        committed_budget: builtins.float = ...,
+        delivery_reconciliation_status: Literal['consistent', 'measurement_variance', 'disputed', 'unmatched', 'closed_unresolved'] = ...,
+        delivery_period_state: Literal['open', 'closed'] = ...,
+        findings: builtins.list[_ReportPlanOutcomeResponseFindingsItem] = ...,
+        plan_summary: _ReportPlanOutcomeResponsePlanSummary = ...,
+        replayed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportUsageRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    reporting_period: _ExternalCoreDatetimeRange
+    usage: builtins.list[_ReportUsageRequestUsageItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        reporting_period: _ExternalCoreDatetimeRange,
+        usage: builtins.list[_ReportUsageRequestUsageItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ReportUsageResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    accepted: builtins.int
+    errors: builtins.list[_ExternalCoreError] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accepted: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class RequestProposalsInputRequiredResponse(VersionedSchemaModel):
+    reason: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class RequestProposalsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    governance_context: builtins.str | None
+    push_notification_config: _RequestProposalsRequestPushNotificationConfig | None
+    idempotency_key: builtins.str
+    account: builtins.dict[builtins.str, Any] | None
+    brand: _ExternalCoreBrandKey | None
+    brief: builtins.str
+    criteria: _ExternalMediaBuyProductDiscoveryCriteria | None
+    opportunity: _RequestProposalsRequestOpportunity | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        brief: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        governance_context: builtins.str = ...,
+        push_notification_config: _RequestProposalsRequestPushNotificationConfig = ...,
+        account: builtins.dict[builtins.str, Any] = ...,
+        brand: _ExternalCoreBrandKey = ...,
+        criteria: _ExternalMediaBuyProductDiscoveryCriteria = ...,
+        opportunity: _RequestProposalsRequestOpportunity = ...,
+    ) -> None: ...
+
+class RequestProposalsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class RequestProposalsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    outcome: Literal['proposed', 'rejected'] | None
+    reason: builtins.str | None
+    suggestions: builtins.list[builtins.str] | None
+    proposals: builtins.list[_RequestProposalsResponseProposalsItem] | None
+    products: builtins.list[_ExternalCoreCanonicalProduct] | None
+    targeting_resolution: _ExternalMediaBuyGetProductsTargetingResolution | None
+    status: Literal['completed', 'submitted'] | None
+    task_id: builtins.str | None
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    replayed: Literal[True] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        outcome: Literal['proposed', 'rejected'] = ...,
+        reason: builtins.str = ...,
+        suggestions: builtins.list[builtins.str] = ...,
+        proposals: builtins.list[_RequestProposalsResponseProposalsItem] = ...,
+        products: builtins.list[_ExternalCoreCanonicalProduct] = ...,
+        targeting_resolution: _ExternalMediaBuyGetProductsTargetingResolution = ...,
+        status: Literal['completed', 'submitted'] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+        replayed: Literal[True] = ...,
+    ) -> None: ...
+
+class RequestProposalsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SearchBrandsRequest(VersionedSchemaModel):
+    adcp_major_version: builtins.int | None
+    query: builtins.str
+    industries: builtins.list[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']] | None
+    countries: builtins.list[builtins.str] | None
+    buyer_brand: _ExternalCoreBrandRef | None
+    pagination: _ExternalCorePaginationRequest | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        query: builtins.str,
+        adcp_major_version: builtins.int = ...,
+        industries: builtins.list[Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']] = ...,
+        countries: builtins.list[builtins.str] = ...,
+        buyer_brand: _ExternalCoreBrandRef = ...,
+        pagination: _ExternalCorePaginationRequest = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SearchBrandsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    brands: builtins.list[_SearchBrandResult] | None
+    pagination: _ExternalCorePaginationResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        brands: builtins.list[_SearchBrandResult],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        pagination: _ExternalCorePaginationResponse = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiGetOfferingRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    offering_id: builtins.str
+    intent: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    include_products: builtins.bool
+    product_limit: builtins.int
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        offering_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        intent: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        include_products: builtins.bool = ...,
+        product_limit: builtins.int = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiGetOfferingResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    available: builtins.bool
+    offering_token: builtins.str | None
+    ttl_seconds: builtins.int | None
+    checked_at: builtins.str | None
+    offering: _SiGetOfferingResponseOffering | None
+    matching_products: builtins.list[_SiGetOfferingResponseMatchingProductsItem] | None
+    sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext | None
+    total_matching: builtins.int | None
+    unavailable_reason: builtins.str | None
+    alternative_offering_ids: builtins.list[builtins.str] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        available: builtins.bool,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        offering_token: builtins.str = ...,
+        ttl_seconds: builtins.int = ...,
+        checked_at: builtins.str = ...,
+        offering: _SiGetOfferingResponseOffering = ...,
+        matching_products: builtins.list[_SiGetOfferingResponseMatchingProductsItem] = ...,
+        sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext = ...,
+        total_matching: builtins.int = ...,
+        unavailable_reason: builtins.str = ...,
+        alternative_offering_ids: builtins.list[builtins.str] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiInitiateSessionRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    intent: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    identity: _ExternalSponsoredIntelligenceSiIdentity
+    media_buy_id: builtins.str | None
+    placement: builtins.str | None
+    offering_id: builtins.str | None
+    supported_capabilities: _ExternalSponsoredIntelligenceSiCapabilities | None
+    offering_token: builtins.str | None
+    sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None
+    idempotency_key: builtins.str
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        intent: builtins.str,
+        identity: _ExternalSponsoredIntelligenceSiIdentity,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        media_buy_id: builtins.str = ...,
+        placement: builtins.str = ...,
+        offering_id: builtins.str = ...,
+        supported_capabilities: _ExternalSponsoredIntelligenceSiCapabilities = ...,
+        offering_token: builtins.str = ...,
+        sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiInitiateSessionResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    session_id: builtins.str
+    response: _SiInitiateSessionResponseResponse | None
+    negotiated_capabilities: _ExternalSponsoredIntelligenceSiCapabilities | None
+    sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext | None
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated']
+    session_ttl_seconds: builtins.int | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        session_id: builtins.str,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        response: _SiInitiateSessionResponseResponse = ...,
+        negotiated_capabilities: _ExternalSponsoredIntelligenceSiCapabilities = ...,
+        sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext = ...,
+        session_ttl_seconds: builtins.int = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiSendMessageRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    session_id: builtins.str
+    message: builtins.str | None
+    action_response: _SiSendMessageRequestActionResponse | None
+    sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        session_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        message: builtins.str = ...,
+        action_response: _SiSendMessageRequestActionResponse = ...,
+        sponsored_context_receipt: _ExternalSponsoredIntelligenceSiSponsoredContextReceipt = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiSendMessageResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    session_id: builtins.str
+    response: _SiSendMessageResponseResponse | None
+    mcp_resource_uri: builtins.str | None
+    sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext | None
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated']
+    handoff: _SiSendMessageResponseHandoff | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        session_id: builtins.str,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        response: _SiSendMessageResponseResponse = ...,
+        mcp_resource_uri: builtins.str = ...,
+        sponsored_context: _ExternalSponsoredIntelligenceSiSponsoredContext = ...,
+        handoff: _SiSendMessageResponseHandoff = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiTerminateSessionRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    session_id: builtins.str
+    reason: Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated']
+    termination_context: _SiTerminateSessionRequestTerminationContext | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        session_id: builtins.str,
+        reason: Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        termination_context: _SiTerminateSessionRequestTerminationContext = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SiTerminateSessionResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    session_id: builtins.str
+    terminated: builtins.bool
+    session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'] | None
+    acp_handoff: _SiTerminateSessionResponseAcpHandoff | None
+    follow_up: _SiTerminateSessionResponseFollowUp | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        session_id: builtins.str,
+        terminated: builtins.bool,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        session_status: Literal['active', 'pending_handoff', 'complete', 'terminated'] = ...,
+        acp_handoff: _SiTerminateSessionResponseAcpHandoff = ...,
+        follow_up: _SiTerminateSessionResponseFollowUp = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class StaleResponse(VersionedSchemaModel):
+    served_from_cache: Literal[True]
+    cache_age_seconds: builtins.int
+    freshness_target_seconds: builtins.int | None
+    upstream: _StaleResponseUpstream | None
+    original_error: _StaleResponseOriginalError | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        served_from_cache: Literal[True],
+        cache_age_seconds: builtins.int,
+        freshness_target_seconds: builtins.int = ...,
+        upstream: _StaleResponseUpstream = ...,
+        original_error: _StaleResponseOriginalError = ...,
+    ) -> None: ...
+
+class SyncAccountsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    accounts: builtins.list[_SyncAccountsRequestAccountsItemVariant1 | _SyncAccountsRequestAccountsItemVariant2]
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        accounts: builtins.list[_SyncAccountsRequestAccountsItemVariant1 | _SyncAccountsRequestAccountsItemVariant2],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAccountsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    accounts: builtins.list[_SyncAccountsResponseAccountsItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accounts: builtins.list[_SyncAccountsResponseAccountsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAgentNotificationConfigsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    notification_configs: builtins.list[_SyncAgentNotificationConfigsRequestNotificationConfigsItem]
+    dry_run: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        notification_configs: builtins.list[_SyncAgentNotificationConfigsRequestNotificationConfigsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        dry_run: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAgentNotificationConfigsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    action: Literal['updated', 'unchanged', 'cleared', 'failed']
+    notification_configs: builtins.list[_ExternalCoreAgentNotificationConfig] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        action: Literal['updated', 'unchanged', 'cleared', 'failed'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        notification_configs: builtins.list[_ExternalCoreAgentNotificationConfig] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAudiencesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncAudiencesRequestAccountVariant1 | _SyncAudiencesRequestAccountVariant2
+    audiences: builtins.list[_SyncAudiencesRequestAudiencesItem] | None
+    delete_missing: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncAudiencesRequestAccountVariant1 | _SyncAudiencesRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        audiences: builtins.list[_SyncAudiencesRequestAudiencesItem] = ...,
+        delete_missing: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncAudiencesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    audiences: builtins.list[_SyncAudiencesResponseAudiencesItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        audiences: builtins.list[_SyncAudiencesResponseAudiencesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncCatalogsRequestAccountVariant1 | _SyncCatalogsRequestAccountVariant2
+    catalogs: builtins.list[_ExternalCoreCatalog] | None
+    item_availability_updates: builtins.list[_ExternalCoreCatalogItemAvailabilityUpdate] | None
+    item_availability_queries: builtins.list[_ExternalCoreCatalogItemAvailabilityRef] | None
+    catalog_ids: builtins.list[builtins.str] | None
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    validation_mode: Literal['strict', 'lenient']
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncCatalogsRequestAccountVariant1 | _SyncCatalogsRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        catalogs: builtins.list[_ExternalCoreCatalog] = ...,
+        item_availability_updates: builtins.list[_ExternalCoreCatalogItemAvailabilityUpdate] = ...,
+        item_availability_queries: builtins.list[_ExternalCoreCatalogItemAvailabilityRef] = ...,
+        catalog_ids: builtins.list[builtins.str] = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        validation_mode: Literal['strict', 'lenient'] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['completed'] | Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    catalogs: builtins.list[_SyncCatalogsResponseCatalogsItem] | None
+    item_availability_updates: builtins.list[_ExternalCoreCatalogItemAvailabilityUpdateResult] | None
+    item_availability_states: builtins.list[_ExternalCoreCatalogItemAvailabilityState] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_SyncCatalogsResponseErrorsItem] | builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['completed'],
+        catalogs: builtins.list[_SyncCatalogsResponseCatalogsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        item_availability_updates: builtins.list[_ExternalCoreCatalogItemAvailabilityUpdateResult] = ...,
+        item_availability_states: builtins.list[_ExternalCoreCatalogItemAvailabilityState] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_SyncCatalogsResponseErrorsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCatalogsWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    catalogs_processed: builtins.int | None
+    catalogs_total: builtins.int | None
+    items_processed: builtins.int | None
+    items_total: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        catalogs_processed: builtins.int = ...,
+        catalogs_total: builtins.int = ...,
+        items_processed: builtins.int = ...,
+        items_total: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _SyncCreativesRequestAccountVariant1 | _SyncCreativesRequestAccountVariant2
+    creatives: builtins.list[_SyncCreativesRequestCreativesItemVariant1 | _SyncCreativesRequestCreativesItemVariant2] | None
+    creative_ids: builtins.list[builtins.str] | None
+    assignments: builtins.list[_SyncCreativesRequestAssignmentsItem] | None
+    assignment_operations: builtins.list[_SyncCreativesRequestAssignmentOperationsItemVariant1 | _SyncCreativesRequestAssignmentOperationsItemVariant2 | _SyncCreativesRequestAssignmentOperationsItemVariant3] | None
+    idempotency_key: builtins.str
+    delete_missing: builtins.bool
+    dry_run: builtins.bool
+    validation_mode: Literal['strict', 'lenient']
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _SyncCreativesRequestAccountVariant1 | _SyncCreativesRequestAccountVariant2,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        creatives: builtins.list[_SyncCreativesRequestCreativesItemVariant1 | _SyncCreativesRequestCreativesItemVariant2] = ...,
+        creative_ids: builtins.list[builtins.str] = ...,
+        assignments: builtins.list[_SyncCreativesRequestAssignmentsItem] = ...,
+        assignment_operations: builtins.list[_SyncCreativesRequestAssignmentOperationsItemVariant1 | _SyncCreativesRequestAssignmentOperationsItemVariant2 | _SyncCreativesRequestAssignmentOperationsItemVariant3] = ...,
+        delete_missing: builtins.bool = ...,
+        dry_run: builtins.bool = ...,
+        validation_mode: Literal['strict', 'lenient'] = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesSubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    dry_run: builtins.bool | None
+    creatives: builtins.list[_SyncCreativesResponseCreativesItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        creatives: builtins.list[_SyncCreativesResponseCreativesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        dry_run: builtins.bool = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncCreativesWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    creatives_processed: builtins.int | None
+    creatives_total: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        creatives_processed: builtins.int = ...,
+        creatives_total: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncEventSourcesRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    account: _SyncEventSourcesRequestAccountVariant1 | _SyncEventSourcesRequestAccountVariant2
+    event_sources: builtins.list[_SyncEventSourcesRequestEventSourcesItem] | None
+    delete_missing: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        account: _SyncEventSourcesRequestAccountVariant1 | _SyncEventSourcesRequestAccountVariant2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        event_sources: builtins.list[_SyncEventSourcesRequestEventSourcesItem] = ...,
+        delete_missing: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncEventSourcesResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    event_sources: builtins.list[_SyncEventSourcesResponseEventSourcesItem] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        event_sources: builtins.list[_SyncEventSourcesResponseEventSourcesItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncGovernanceRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    accounts: builtins.list[_SyncGovernanceRequestAccountsItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        accounts: builtins.list[_SyncGovernanceRequestAccountsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncGovernanceResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    accounts: builtins.list[_SyncGovernanceResponseAccountsItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        accounts: builtins.list[_SyncGovernanceResponseAccountsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncPlansRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    idempotency_key: builtins.str
+    plans: builtins.list[_SyncPlansRequestPlansItem]
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        idempotency_key: builtins.str,
+        plans: builtins.list[_SyncPlansRequestPlansItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class SyncPlansResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    plans: builtins.list[_SyncPlansResponsePlansItem]
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        plans: builtins.list[_SyncPlansResponsePlansItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksGetRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    task_id: builtins.str
+    account: _TasksGetRequestAccountVariant1 | _TasksGetRequestAccountVariant2 | None
+    include_history: builtins.bool
+    include_result: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _TasksGetRequestAccountVariant1 | _TasksGetRequestAccountVariant2 = ...,
+        include_history: builtins.bool = ...,
+        include_result: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksGetResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _TasksGetResponseAdcpError | None
+    push_notification_config: _TasksGetResponsePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    task_type: Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']
+    protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']
+    created_at: builtins.str
+    updated_at: builtins.str
+    completed_at: builtins.str | None
+    has_webhook: builtins.bool | None
+    progress: _TasksGetResponseProgress | None
+    error: _TasksGetResponseError | None
+    history: builtins.list[_TasksGetResponseHistoryItem] | None
+    result: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        task_type: Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs'],
+        protocol: Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement'],
+        created_at: builtins.str,
+        updated_at: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _TasksGetResponseAdcpError = ...,
+        push_notification_config: _TasksGetResponsePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        completed_at: builtins.str = ...,
+        has_webhook: builtins.bool = ...,
+        progress: _TasksGetResponseProgress = ...,
+        error: _TasksGetResponseError = ...,
+        history: builtins.list[_TasksGetResponseHistoryItem] = ...,
+        result: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    account: _TasksListRequestAccountVariant1 | _TasksListRequestAccountVariant2 | None
+    filters: _TasksListRequestFilters | None
+    sort: _TasksListRequestSort | None
+    pagination: _TasksListRequestPagination | None
+    include_history: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _TasksListRequestAccountVariant1 | _TasksListRequestAccountVariant2 = ...,
+        filters: _TasksListRequestFilters = ...,
+        sort: _TasksListRequestSort = ...,
+        pagination: _TasksListRequestPagination = ...,
+        include_history: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class TasksListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _TasksListResponseAdcpError | None
+    push_notification_config: _TasksListResponsePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    query_summary: _TasksListResponseQuerySummary
+    tasks: builtins.list[_TasksListResponseTasksItem]
+    pagination: _TasksListResponsePagination
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        query_summary: _TasksListResponseQuerySummary,
+        tasks: builtins.list[_TasksListResponseTasksItem],
+        pagination: _TasksListResponsePagination,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _TasksListResponseAdcpError = ...,
+        push_notification_config: _TasksListResponsePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateCollectionListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _UpdateCollectionListRequestAccountVariant1 | _UpdateCollectionListRequestAccountVariant2 | None
+    name: builtins.str | None
+    description: builtins.str | None
+    base_collections: builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1 | _UpdateCollectionListRequestBaseCollectionsItemVariant2 | _UpdateCollectionListRequestBaseCollectionsItemVariant3] | None
+    filters: _ExternalCollectionCollectionListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    webhook_url: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdateCollectionListRequestAccountVariant1 | _UpdateCollectionListRequestAccountVariant2 = ...,
+        name: builtins.str = ...,
+        description: builtins.str = ...,
+        base_collections: builtins.list[_UpdateCollectionListRequestBaseCollectionsItemVariant1 | _UpdateCollectionListRequestBaseCollectionsItemVariant2 | _UpdateCollectionListRequestBaseCollectionsItemVariant3] = ...,
+        filters: _ExternalCollectionCollectionListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        webhook_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateCollectionListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalCollectionCollectionList
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalCollectionCollectionList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateContentStandardsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    scope: _UpdateContentStandardsRequestScope | None
+    registry_policy_ids: builtins.list[builtins.str] | None
+    policies: builtins.list[_ExternalGovernancePolicyEntry] | None
+    calibration_exemplars: _UpdateContentStandardsRequestCalibrationExemplars | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        scope: _UpdateContentStandardsRequestScope = ...,
+        registry_policy_ids: builtins.list[builtins.str] = ...,
+        policies: builtins.list[_ExternalGovernancePolicyEntry] = ...,
+        calibration_exemplars: _UpdateContentStandardsRequestCalibrationExemplars = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateContentStandardsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    success: Literal[True] | Literal[False]
+    standards_id: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+    conflicting_standards_id: builtins.str | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[True],
+        standards_id: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        success: Literal[False],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        conflicting_standards_id: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyInputRequiredResponse(VersionedSchemaModel):
+    reason: Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        reason: Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    governance_context: builtins.str | None
+    account: _UpdateMediaBuyRequestAccountVariant1 | _UpdateMediaBuyRequestAccountVariant2
+    media_buy_id: builtins.str
+    name: builtins.str | None
+    revision: builtins.int | None
+    paused: builtins.bool | None
+    canceled: Literal[True] | None
+    cancellation_reason: builtins.str | None
+    start_time: Literal['asap'] | builtins.str | None
+    end_time: builtins.str | None
+    total_budget: _UpdateMediaBuyRequestTotalBudget | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    budget_allocation: _UpdateMediaBuyRequestBudgetAllocationVariant1 | _UpdateMediaBuyRequestBudgetAllocationVariant2 | None
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    bidding: _ExternalCoreBiddingPolicy | None
+    packages: builtins.list[_ExternalMediaBuyPackageUpdate] | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    new_packages: builtins.list[_ExternalMediaBuyPackageRequest] | None
+    reporting_webhook: _ExternalCoreReportingWebhook | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        account: _UpdateMediaBuyRequestAccountVariant1 | _UpdateMediaBuyRequestAccountVariant2,
+        media_buy_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        governance_context: builtins.str = ...,
+        name: builtins.str = ...,
+        revision: builtins.int = ...,
+        paused: builtins.bool = ...,
+        canceled: Literal[True] = ...,
+        cancellation_reason: builtins.str = ...,
+        start_time: Literal['asap'] | builtins.str = ...,
+        end_time: builtins.str = ...,
+        total_budget: _UpdateMediaBuyRequestTotalBudget = ...,
+        daily_budget_cap: builtins.float | None = ...,
+        budget_cap_timezone: builtins.str | None = ...,
+        budget_allocation: _UpdateMediaBuyRequestBudgetAllocationVariant1 | _UpdateMediaBuyRequestBudgetAllocationVariant2 = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bidding: _ExternalCoreBiddingPolicy | None = ...,
+        packages: builtins.list[_ExternalMediaBuyPackageUpdate] = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        new_packages: builtins.list[_ExternalMediaBuyPackageRequest] = ...,
+        reporting_webhook: _ExternalCoreReportingWebhook = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuySubmittedResponse(VersionedSchemaModel):
+    status: Literal['submitted']
+    task_id: builtins.str
+    message: builtins.str | None
+    errors: builtins.list[_ExternalCoreError] | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted'],
+        task_id: builtins.str,
+        message: builtins.str = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    media_buy_id: builtins.str | None
+    name: builtins.str | None
+    media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None
+    revision: builtins.int | None
+    currency: builtins.str | None
+    total_budget: builtins.float | None
+    daily_budget_cap: builtins.float | None
+    budget_cap_timezone: builtins.str | None
+    budget_allocation: _UpdateMediaBuyResponseBudgetAllocationVariant1 | _UpdateMediaBuyResponseBudgetAllocationVariant2 | None
+    pacing: Literal['even', 'asap', 'front_loaded'] | None
+    bidding: _UpdateMediaBuyResponseBidding | None
+    implementation_date: builtins.str | None
+    invoice_recipient: _ExternalCoreBusinessEntity | None
+    affected_packages: builtins.list[_ExternalCorePackage] | None
+    valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | None
+    available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] | None
+    warnings: builtins.list[_ExternalCoreWarning] | None
+    sandbox: builtins.bool | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        media_buy_id: builtins.str,
+        revision: builtins.int,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        name: builtins.str = ...,
+        media_buy_status: Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] = ...,
+        currency: builtins.str = ...,
+        total_budget: builtins.float = ...,
+        daily_budget_cap: builtins.float = ...,
+        budget_cap_timezone: builtins.str = ...,
+        budget_allocation: _UpdateMediaBuyResponseBudgetAllocationVariant1 | _UpdateMediaBuyResponseBudgetAllocationVariant2 = ...,
+        pacing: Literal['even', 'asap', 'front_loaded'] = ...,
+        bidding: _UpdateMediaBuyResponseBidding = ...,
+        implementation_date: builtins.str | None = ...,
+        invoice_recipient: _ExternalCoreBusinessEntity = ...,
+        affected_packages: builtins.list[_ExternalCorePackage] = ...,
+        valid_actions: builtins.list[Literal['pause', 'resume', 'cancel', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] = ...,
+        available_actions: builtins.list[_ExternalCoreMediaBuyAvailableAction] = ...,
+        warnings: builtins.list[_ExternalCoreWarning] = ...,
+        sandbox: builtins.bool = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        task_id: builtins.str,
+        status: Literal['submitted'],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        errors: builtins.list[_ExternalCoreError] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateMediaBuyWorkingResponse(VersionedSchemaModel):
+    percentage: builtins.float | None
+    current_step: builtins.str | None
+    total_steps: builtins.int | None
+    step_number: builtins.int | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        percentage: builtins.float = ...,
+        current_step: builtins.str = ...,
+        total_steps: builtins.int = ...,
+        step_number: builtins.int = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdatePropertyListRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _UpdatePropertyListRequestAccountVariant1 | _UpdatePropertyListRequestAccountVariant2 | None
+    name: builtins.str | None
+    description: builtins.str | None
+    base_properties: builtins.list[_UpdatePropertyListRequestBasePropertiesItemVariant1 | _UpdatePropertyListRequestBasePropertiesItemVariant2 | _UpdatePropertyListRequestBasePropertiesItemVariant3] | None
+    filters: _ExternalPropertyPropertyListFilters | None
+    brand: _ExternalCoreBrandRef | None
+    webhook_url: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    idempotency_key: builtins.str
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _UpdatePropertyListRequestAccountVariant1 | _UpdatePropertyListRequestAccountVariant2 = ...,
+        name: builtins.str = ...,
+        description: builtins.str = ...,
+        base_properties: builtins.list[_UpdatePropertyListRequestBasePropertiesItemVariant1 | _UpdatePropertyListRequestBasePropertiesItemVariant2 | _UpdatePropertyListRequestBasePropertiesItemVariant3] = ...,
+        filters: _ExternalPropertyPropertyListFilters = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        webhook_url: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdatePropertyListResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    list: _ExternalPropertyPropertyList
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list: _ExternalPropertyPropertyList,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateRightsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    governance_context: builtins.str | None
+    rights_id: builtins.str
+    account: _UpdateRightsRequestAccountVariant1 | _UpdateRightsRequestAccountVariant2 | None
+    end_date: builtins.str | None
+    impression_cap: builtins.int | None
+    pricing_option_id: builtins.str | None
+    paused: builtins.bool | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    idempotency_key: builtins.str
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        rights_id: builtins.str,
+        idempotency_key: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        governance_context: builtins.str = ...,
+        account: _UpdateRightsRequestAccountVariant1 | _UpdateRightsRequestAccountVariant2 = ...,
+        end_date: builtins.str = ...,
+        impression_cap: builtins.int = ...,
+        pricing_option_id: builtins.str = ...,
+        paused: builtins.bool = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class UpdateRightsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    rights_id: builtins.str | None
+    terms: _ExternalBrandRightsTerms | None
+    generation_credentials: builtins.list[_ExternalCoreGenerationCredential] | None
+    rights_constraint: _UpdateRightsResponseRightsConstraint | None
+    paused: builtins.bool | None
+    implementation_date: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        rights_id: builtins.str,
+        terms: _ExternalBrandRightsTerms,
+        generation_credentials: builtins.list[_ExternalCoreGenerationCredential],
+        rights_constraint: _UpdateRightsResponseRightsConstraint,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        paused: builtins.bool = ...,
+        implementation_date: builtins.str | None = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateContentDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    standards_id: builtins.str
+    records: builtins.list[_ValidateContentDeliveryRequestRecordsItem]
+    feature_ids: builtins.list[builtins.str] | None
+    include_passed: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        standards_id: builtins.str,
+        records: builtins.list[_ValidateContentDeliveryRequestRecordsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        feature_ids: builtins.list[builtins.str] = ...,
+        include_passed: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateContentDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    summary: _ValidateContentDeliveryResponseSummary | None
+    results: builtins.list[_ValidateContentDeliveryResponseResultsItem] | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        summary: _ValidateContentDeliveryResponseSummary,
+        results: builtins.list[_ValidateContentDeliveryResponseResultsItem],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidateInputRequest(VersionedSchemaModel):
+    account: _ValidateInputRequestAccountVariant1 | _ValidateInputRequestAccountVariant2 | None
+    brand: _ExternalCoreBrandRef | None
+    manifest: _ValidateInputRequestManifestVariant1 | _ValidateInputRequestManifestVariant2
+    targets: builtins.list[_ValidateInputRequestTargetsItemVariant1 | _ValidateInputRequestTargetsItemVariant2 | _ValidateInputRequestTargetsItemVariant3 | _ValidateInputRequestTargetsItemVariant4] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        manifest: _ValidateInputRequestManifestVariant1 | _ValidateInputRequestManifestVariant2,
+        account: _ValidateInputRequestAccountVariant1 | _ValidateInputRequestAccountVariant2 = ...,
+        brand: _ExternalCoreBrandRef = ...,
+        targets: builtins.list[_ValidateInputRequestTargetsItemVariant1 | _ValidateInputRequestTargetsItemVariant2 | _ValidateInputRequestTargetsItemVariant3 | _ValidateInputRequestTargetsItemVariant4] = ...,
+    ) -> None: ...
+
+class ValidateInputResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_ExternalCreativeValidateInputResult]
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        results: builtins.list[_ExternalCreativeValidateInputResult],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidatePropertyDeliveryRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    list_id: builtins.str
+    account: _ValidatePropertyDeliveryRequestAccountVariant1 | _ValidatePropertyDeliveryRequestAccountVariant2 | None
+    records: builtins.list[_ExternalPropertyDeliveryRecord]
+    include_compliant: builtins.bool
+    context: builtins.dict[builtins.str, Any] | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        list_id: builtins.str,
+        records: builtins.list[_ExternalPropertyDeliveryRecord],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        account: _ValidatePropertyDeliveryRequestAccountVariant1 | _ValidatePropertyDeliveryRequestAccountVariant2 = ...,
+        include_compliant: builtins.bool = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class ValidatePropertyDeliveryResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    compliant: builtins.bool | None
+    list_id: builtins.str
+    summary: _ValidatePropertyDeliveryResponseSummary
+    aggregate: _ValidatePropertyDeliveryResponseAggregate | None
+    authorization_summary: _ValidatePropertyDeliveryResponseAuthorizationSummary | None
+    results: builtins.list[_ExternalPropertyValidationResult]
+    validated_at: builtins.str
+    list_resolved_at: builtins.str | None
+    ext: builtins.dict[builtins.str, Any] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        list_id: builtins.str,
+        summary: _ValidatePropertyDeliveryResponseSummary,
+        results: builtins.list[_ExternalPropertyValidationResult],
+        validated_at: builtins.str,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        compliant: builtins.bool = ...,
+        aggregate: _ValidatePropertyDeliveryResponseAggregate = ...,
+        authorization_summary: _ValidatePropertyDeliveryResponseAuthorizationSummary = ...,
+        list_resolved_at: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    claim_type: Literal['subsidiary'] | Literal['parent'] | Literal['property'] | Literal['trademark']
+    claim: _VerifyBrandClaimRequestClaim | _VerifyBrandClaimRequestClaim2 | _VerifyBrandClaimRequestClaim3 | _VerifyBrandClaimRequestClaim4
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['subsidiary'],
+        claim: _VerifyBrandClaimRequestClaim,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['parent'],
+        claim: _VerifyBrandClaimRequestClaim2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['property'],
+        claim: _VerifyBrandClaimRequestClaim3,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claim_type: Literal['trademark'],
+        claim: _VerifyBrandClaimRequestClaim4,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    claim_type: Literal['subsidiary', 'parent', 'property', 'trademark'] | None
+    verification_status: Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown'] | None
+    details: builtins.dict[builtins.str, Any] | None
+    context_note: builtins.str | None
+    signed_response: _SignedResponse | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        claim_type: Literal['subsidiary', 'parent', 'property', 'trademark'],
+        verification_status: Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown'],
+        signed_response: _SignedResponse,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        details: builtins.dict[builtins.str, Any] = ...,
+        context_note: builtins.str = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimsRequest(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    claims: builtins.list[_VerifyBrandClaimsRequestClaimsItemVariant1 | _VerifyBrandClaimsRequestClaimsItemVariant2 | _VerifyBrandClaimsRequestClaimsItemVariant3 | _VerifyBrandClaimsRequestClaimsItemVariant4]
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        claims: builtins.list[_VerifyBrandClaimsRequestClaimsItemVariant1 | _VerifyBrandClaimsRequestClaimsItemVariant2 | _VerifyBrandClaimsRequestClaimsItemVariant3 | _VerifyBrandClaimsRequestClaimsItemVariant4],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+    ) -> None: ...
+
+class VerifyBrandClaimsResponse(VersionedSchemaModel):
+    adcp_version: builtins.str | None
+    adcp_major_version: builtins.int | None
+    context_id: builtins.str | None
+    context: builtins.dict[builtins.str, Any] | None
+    task_id: builtins.str | None
+    status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']
+    message: builtins.str | None
+    timestamp: builtins.str | None
+    replayed: builtins.bool | None
+    adcp_error: _ExternalCoreError | None
+    push_notification_config: _ExternalCorePushNotificationConfig | None
+    governance_context: builtins.str | None
+    payload: builtins.dict[builtins.str, Any] | None
+    results: builtins.list[_VerifyBrandClaimsResponseResultsItemVariant1 | _VerifyBrandClaimsResponseResultsItemVariant2] | None
+    signed_response: _SignedResponse2 | None
+    ext: builtins.dict[builtins.str, Any] | None
+    errors: builtins.list[_ExternalCoreError] | None
+
+    @overload
+    def __init__(self, root: builtins.dict[builtins.str, Any], /) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        results: builtins.list[_VerifyBrandClaimsResponseResultsItemVariant1 | _VerifyBrandClaimsResponseResultsItemVariant2],
+        signed_response: _SignedResponse2,
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        status: Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'],
+        errors: builtins.list[_ExternalCoreError],
+        adcp_version: builtins.str = ...,
+        adcp_major_version: builtins.int = ...,
+        context_id: builtins.str = ...,
+        context: builtins.dict[builtins.str, Any] = ...,
+        task_id: builtins.str = ...,
+        message: builtins.str = ...,
+        timestamp: builtins.str = ...,
+        replayed: builtins.bool = ...,
+        adcp_error: _ExternalCoreError = ...,
+        push_notification_config: _ExternalCorePushNotificationConfig = ...,
+        governance_context: builtins.str = ...,
+        payload: builtins.dict[builtins.str, Any] = ...,
+        ext: builtins.dict[builtins.str, Any] = ...,
+    ) -> None: ...
+
+__all__ = ['AcceptProposalInputRequiredResponse', 'AcceptProposalRequest', 'AcceptProposalSubmittedResponse', 'AcceptProposalResponse', 'AcceptProposalWorkingResponse', 'AcquireRightsRequest', 'AcquireRightsResponse', 'ActivateSignalRequest', 'ActivateSignalResponse', 'BuildCreativeInputRequiredResponse', 'BuildCreativeRequest', 'BuildCreativeSubmittedResponse', 'BuildCreativeResponse', 'BuildCreativeWorkingResponse', 'BuyProductsInputRequiredResponse', 'BuyProductsRequest', 'BuyProductsSubmittedResponse', 'BuyProductsResponse', 'BuyProductsWorkingResponse', 'CalibrateContentRequest', 'CalibrateContentResponse', 'CheckGovernanceRequest', 'CheckGovernanceResponse', 'ComplyTestControllerRequest', 'ComplyTestControllerResponse', 'ContextMatchRequest', 'ContextMatchResponse', 'ControlMediaBuyInputRequiredResponse', 'ControlMediaBuyRequest', 'ControlMediaBuySubmittedResponse', 'ControlMediaBuyResponse', 'ControlMediaBuyWorkingResponse', 'CreateCollectionListRequest', 'CreateCollectionListResponse', 'CreateContentStandardsRequest', 'CreateContentStandardsResponse', 'CreateMediaBuyInputRequiredResponse', 'CreateMediaBuyRequest', 'CreateMediaBuySubmittedResponse', 'CreateMediaBuyResponse', 'CreateMediaBuyWorkingResponse', 'CreatePropertyListRequest', 'CreatePropertyListResponse', 'CreativeApprovalRequest', 'CreativeApprovalResponse', 'DeclineProposalsInputRequiredResponse', 'DeclineProposalsRequest', 'DeclineProposalsSubmittedResponse', 'DeclineProposalsResponse', 'DeclineProposalsWorkingResponse', 'DeleteCollectionListRequest', 'DeleteCollectionListResponse', 'DeletePropertyListRequest', 'DeletePropertyListResponse', 'GetAccountFinancialsRequest', 'GetAccountFinancialsResponse', 'GetAdcpCapabilitiesRequest', 'GetAdcpCapabilitiesResponse', 'GetBrandIdentityRequest', 'GetBrandIdentityResponse', 'GetCollectionListRequest', 'GetCollectionListResponse', 'GetContentStandardsRequest', 'GetContentStandardsResponse', 'GetCreativeDeliveryRequest', 'GetCreativeDeliveryResponse', 'GetCreativeFeaturesRequest', 'GetCreativeFeaturesResponse', 'GetMediaBuyArtifactsRequest', 'GetMediaBuyArtifactsResponse', 'GetMediaBuyDeliveryRequest', 'GetMediaBuyDeliveryResponse', 'GetMediaBuysRequest', 'GetMediaBuysResponse', 'GetPlanAuditLogsRequest', 'GetPlanAuditLogsResponse', 'GetProductsInputRequiredResponse', 'GetProductsRequest', 'GetProductsSubmittedResponse', 'GetProductsResponse', 'GetProductsWorkingResponse', 'GetPropertyListRequest', 'GetPropertyListResponse', 'GetRightsRequest', 'GetRightsResponse', 'GetSignalsRequest', 'GetSignalsSubmittedResponse', 'GetSignalsResponse', 'GetSignalsWorkingResponse', 'GetTaskStatusRequest', 'GetTaskStatusResponse', 'IdentityMatchRequest', 'IdentityMatchResponse', 'ListAccountsRequest', 'ListAccountsResponse', 'ListCollectionListsRequest', 'ListCollectionListsResponse', 'ListContentStandardsRequest', 'ListContentStandardsResponse', 'ListCreativeFormatsRequest', 'ListCreativeFormatsResponse', 'ListCreativesRequest', 'ListCreativesResponse', 'ListProductsRequest', 'ListProductsResponse', 'ListPropertyListsRequest', 'ListPropertyListsResponse', 'ListTasksRequest', 'ListTasksResponse', 'ListTransformersRequest', 'ListTransformersResponse', 'LogEventRequest', 'LogEventResponse', 'MediaBuyCommitmentResponse', 'PackageRequest', 'PreviewCreativeRequest', 'PreviewCreativeResponse', 'ProvidePerformanceFeedbackRequest', 'ProvidePerformanceFeedbackResponse', 'ProviderContextMatchResponse', 'ProviderIdentityMatchResponse', 'RefineProposalsInputRequiredResponse', 'RefineProposalsRequest', 'RefineProposalsSubmittedResponse', 'RefineProposalsResponse', 'RefineProposalsWorkingResponse', 'ReportPlanAdjustmentRequest', 'ReportPlanAdjustmentResponse', 'ReportPlanOutcomeRequest', 'ReportPlanOutcomeResponse', 'ReportUsageRequest', 'ReportUsageResponse', 'RequestProposalsInputRequiredResponse', 'RequestProposalsRequest', 'RequestProposalsSubmittedResponse', 'RequestProposalsResponse', 'RequestProposalsWorkingResponse', 'SearchBrandsRequest', 'SearchBrandsResponse', 'SiGetOfferingRequest', 'SiGetOfferingResponse', 'SiInitiateSessionRequest', 'SiInitiateSessionResponse', 'SiSendMessageRequest', 'SiSendMessageResponse', 'SiTerminateSessionRequest', 'SiTerminateSessionResponse', 'StaleResponse', 'SyncAccountsRequest', 'SyncAccountsResponse', 'SyncAgentNotificationConfigsRequest', 'SyncAgentNotificationConfigsResponse', 'SyncAudiencesRequest', 'SyncAudiencesResponse', 'SyncCatalogsInputRequiredResponse', 'SyncCatalogsRequest', 'SyncCatalogsSubmittedResponse', 'SyncCatalogsResponse', 'SyncCatalogsWorkingResponse', 'SyncCreativesInputRequiredResponse', 'SyncCreativesRequest', 'SyncCreativesSubmittedResponse', 'SyncCreativesResponse', 'SyncCreativesWorkingResponse', 'SyncEventSourcesRequest', 'SyncEventSourcesResponse', 'SyncGovernanceRequest', 'SyncGovernanceResponse', 'SyncPlansRequest', 'SyncPlansResponse', 'TasksGetRequest', 'TasksGetResponse', 'TasksListRequest', 'TasksListResponse', 'UpdateCollectionListRequest', 'UpdateCollectionListResponse', 'UpdateContentStandardsRequest', 'UpdateContentStandardsResponse', 'UpdateMediaBuyInputRequiredResponse', 'UpdateMediaBuyRequest', 'UpdateMediaBuySubmittedResponse', 'UpdateMediaBuyResponse', 'UpdateMediaBuyWorkingResponse', 'UpdatePropertyListRequest', 'UpdatePropertyListResponse', 'UpdateRightsRequest', 'UpdateRightsResponse', 'ValidateContentDeliveryRequest', 'ValidateContentDeliveryResponse', 'ValidateInputRequest', 'ValidateInputResponse', 'ValidatePropertyDeliveryRequest', 'ValidatePropertyDeliveryResponse', 'VerifyBrandClaimRequest', 'VerifyBrandClaimResponse', 'VerifyBrandClaimsRequest', 'VerifyBrandClaimsResponse']
diff --git a/src/adcp/types/versioned.py b/src/adcp/types/versioned.py
index 8b7734aad..a6578a785 100644
--- a/src/adcp/types/versioned.py
+++ b/src/adcp/types/versioned.py
@@ -3,10 +3,12 @@
 The primary :mod:`adcp.types` surface represents the SDK's current generated
 release. Use this module (or ``adcp.types.v30`` / ``v31`` / ``v32``) when an
 application must construct and validate the exact public shape negotiated with
-an older peer in the same SDK process. These models are exact-schema boundary
-validators and schema sources; because they are ``RootModel[dict[str, Any]]``
-wrappers, they are not drop-in, statically typed base classes for
-adopter-defined models.
+an older peer in the same SDK process. Generated ``.pyi`` files expose exact
+field, nested-value, and direct constructor requiredness information to type
+checkers; conditional JSON Schema constraints remain runtime-only. At runtime
+these remain exact-schema ``RootModel[dict[str, Any]]`` boundary validators, so
+subclassing them to add Pydantic fields is not supported; compose adopter-only
+state beside the versioned model instead.
 """
 
 from __future__ import annotations
@@ -34,6 +36,60 @@
     "input-required",
 ]
 
+_ObjectShape = tuple[dict[str, Any], set[str]]
+
+
+def _merge_object_shapes(left: list[_ObjectShape], right: list[_ObjectShape]) -> list[_ObjectShape]:
+    return [
+        ({**left_properties, **right_properties}, left_required | right_required)
+        for left_properties, left_required in left
+        for right_properties, right_required in right
+    ]
+
+
+def _object_shapes(
+    schema: dict[str, Any],
+    document: dict[str, Any],
+    seen: frozenset[str] = frozenset(),
+) -> list[_ObjectShape]:
+    """Return every top-level object shape admitted by a bundled schema."""
+    shapes: list[_ObjectShape] = [({}, set())]
+    reference = schema.get("$ref")
+    if isinstance(reference, str) and reference.startswith("#/") and reference not in seen:
+        target: Any = document
+        for raw_part in reference.removeprefix("#/").split("/"):
+            part = raw_part.replace("~1", "/").replace("~0", "~")
+            target = target[part]
+        if isinstance(target, dict):
+            shapes = _merge_object_shapes(
+                shapes,
+                _object_shapes(target, document, seen | {reference}),
+            )
+    for part in schema.get("allOf", []):
+        if isinstance(part, dict):
+            shapes = _merge_object_shapes(shapes, _object_shapes(part, document, seen))
+
+    properties = schema.get("properties", {})
+    own_properties = properties if isinstance(properties, dict) else {}
+    required = schema.get("required", [])
+    own_required = {item for item in required if isinstance(item, str)}
+    shapes = [
+        ({**shape_properties, **own_properties}, shape_required | own_required)
+        for shape_properties, shape_required in shapes
+    ]
+
+    alternatives = schema.get("oneOf") or schema.get("anyOf")
+    if isinstance(alternatives, list) and alternatives:
+        alternative_shapes = [
+            shape
+            for alternative in alternatives
+            if isinstance(alternative, dict)
+            for shape in _object_shapes(alternative, document, seen)
+        ]
+        if alternative_shapes:
+            shapes = _merge_object_shapes(shapes, alternative_shapes)
+    return shapes
+
 
 def _inline_local_refs(schema: dict[str, Any]) -> dict[str, Any]:
     """Inline bundled definitions for Pydantic's schema post-processor."""
@@ -71,15 +127,16 @@ class VersionedSchemaModel(RootModel[dict[str, Any]]):
 
     Keyword construction and attribute access intentionally mirror ordinary
     generated request models while retaining the exact JSON Schema as the
-    validation authority. Schema fields are not statically typed model fields,
-    so this wrapper is intended for boundary validation and schema generation,
-    not as a base class for adopter-defined models.
+    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.
     """
 
     schema_version: ClassVar[str]
     schema_tool_name: ClassVar[str]
     schema_direction: ClassVar[VersionedDirection]
     schema_document: ClassVar[dict[str, Any]]
+    optional_fields: ClassVar[frozenset[str]]
 
     def __init__(self, root: dict[str, Any] | None = None, **data: Any) -> None:
         if root is not None and data:
@@ -126,6 +183,8 @@ def __getattr__(self, name: str) -> Any:
         root = object.__getattribute__(self, "root")
         if name in root:
             return root[name]
+        if name in type(self).optional_fields:
+            return None
         raise AttributeError(f"{type(self).__name__!s} has no attribute {name!r}")
 
     def __getitem__(self, name: str) -> Any:
@@ -176,6 +235,16 @@ def schema_model_for_version(
         "input-required": "InputRequiredResponse",
     }[direction]
     name = model_name or f"{_pascal_case(tool_name)}{suffix}"
+    shapes = _object_shapes(schema, schema)
+    known_fields = {field for properties, _required in shapes for field in properties}
+    guaranteed_fields = set.intersection(*(required for _properties, required in shapes))
+    properties = schema.get("properties", {})
+    if isinstance(properties, dict):
+        guaranteed_fields.update(
+            field
+            for field, field_schema in properties.items()
+            if isinstance(field_schema, dict) and "default" in field_schema
+        )
     return type(
         name,
         (VersionedSchemaModel,),
@@ -185,6 +254,7 @@ def schema_model_for_version(
             "schema_tool_name": tool_name,
             "schema_direction": direction,
             "schema_document": schema,
+            "optional_fields": frozenset(known_fields - guaranteed_fields),
         },
     )
 
diff --git a/tests/fixtures/public_api_snapshot.json b/tests/fixtures/public_api_snapshot.json
index 69dff9c28..8a98ce725 100644
--- a/tests/fixtures/public_api_snapshot.json
+++ b/tests/fixtures/public_api_snapshot.json
@@ -580,6 +580,7 @@
     "AcceptProposalResponse",
     "Account",
     "AccountAuthorization",
+    "AccountIdReference",
     "AccountReference",
     "AccountReferenceById",
     "AccountReferenceByNaturalKey",
@@ -723,6 +724,7 @@
     "CpmAuctionPricingOption",
     "CpmFixedRatePricingOption",
     "CpmPricingOption",
+    "CpmVendorPricingOption",
     "CppPricingOption",
     "CpvPricingOption",
     "CreateCollectionListRequest",
@@ -758,6 +760,7 @@
     "CssContent",
     "CssFormatAsset",
     "CssFormatGroupAsset",
+    "CustomVendorPricingOption",
     "DaastAsset",
     "DaastFormatAsset",
     "DaastFormatGroupAsset",
@@ -800,6 +803,7 @@
     "FeedFormat",
     "FeedbackSource",
     "FieldModel",
+    "FlatFeeVendorPricingOption",
     "FlatRatePricingOption",
     "Fonts",
     "ForecastMethod",
@@ -906,6 +910,7 @@
     "ImageContent",
     "ImageFormatAsset",
     "ImageFormatGroupAsset",
+    "InlineAccountReference",
     "InlineDaastAsset",
     "InlineVastAsset",
     "Input",
@@ -959,6 +964,7 @@
     "LegacyProductFilters",
     "LegacyProductFormatDeclaration",
     "LegacySyncCreativesRequest",
+    "LegacyUpdateMediaBuyErrorResponse",
     "LegacyUpdateMediaBuyRequest",
     "ListAccountsRequest",
     "ListAccountsResponse",
@@ -1011,6 +1017,7 @@
     "Metadata",
     "Method",
     "MetricType",
+    "MissingMetric",
     "ModuleType",
     "NotificationAuthentication",
     "NotificationConfig",
@@ -1036,6 +1043,8 @@
     "PaginationResponse",
     "Parameters",
     "PaymentTerms",
+    "PerUnitVendorPricingOption",
+    "PercentOfMediaVendorPricingOption",
     "Performance",
     "PerformanceFeedback",
     "PixelTrackerAsset",
@@ -1060,6 +1069,7 @@
     "PricingOption",
     "PrimaryCountry",
     "Product",
+    "ProductAllocation",
     "ProductCard",
     "ProductCardDetailed",
     "ProductCatalog",
@@ -1161,6 +1171,8 @@
     "Signal",
     "SignalAvailabilityType",
     "SignalCatalogType",
+    "SignalCoverageForecast",
+    "SignalCoverageRange",
     "SignalDefinitionEnrichment",
     "SignalFilters",
     "SignalListing",
@@ -1242,6 +1254,7 @@
     "Totals",
     "TrackingEvent",
     "Transform",
+    "TrustedMatch",
     "Unit",
     "UnknownFormatAsset",
     "UnknownGroupAsset",
@@ -1299,6 +1312,7 @@
     "VcpmFixedRatePricingOption",
     "VcpmPricingOption",
     "VehicleUnit",
+    "VendorPricingOptionUnion",
     "VenueBreakdownItem",
     "VerifyBrandClaimPayload",
     "VerifyBrandClaimRequest",
diff --git a/tests/test_a2a_server.py b/tests/test_a2a_server.py
index 8510acfd5..9f382d6a2 100644
--- a/tests/test_a2a_server.py
+++ b/tests/test_a2a_server.py
@@ -205,6 +205,32 @@ def _first_data_part(task: pb.Task) -> dict[str, Any]:
 # ---------------------------------------------------------------------------
 
 
+def test_executor_uses_handler_version_for_schema_and_unnegotiated_dispatch(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import adcp.server.a2a_server as a2a_server_module
+
+    seen: dict[str, str | None] = {}
+
+    class _PinnedHandler(_TestHandler):
+        def get_adcp_version(self) -> str:
+            return "3.1"
+
+    def fake_tools(_handler: Any, **kwargs: Any) -> list[dict[str, str]]:
+        seen["schema"] = kwargs.get("adcp_version")
+        return [{"name": "get_products"}]
+
+    def fake_caller(_handler: Any, _name: str, **kwargs: Any) -> object:
+        seen["dispatch"] = kwargs.get("default_unnegotiated_adcp_version")
+        return object()
+
+    monkeypatch.setattr(a2a_server_module, "get_tools_for_handler", fake_tools)
+    monkeypatch.setattr(a2a_server_module, "create_tool_caller", fake_caller)
+    ADCPAgentExecutor(_PinnedHandler())
+
+    assert seen == {"schema": "3.1", "dispatch": "3.1"}
+
+
 def test_executor_supported_skills():
     executor = ADCPAgentExecutor(_TestHandler())
     skills = executor.supported_skills
diff --git a/tests/test_collision_aliases.py b/tests/test_collision_aliases.py
index 3695f5967..41e61f5ab 100644
--- a/tests/test_collision_aliases.py
+++ b/tests/test_collision_aliases.py
@@ -20,6 +20,29 @@
 
 # (alias name, source module under generated_poc, base class name in that module)
 COLLISION_ALIASES: list[tuple[str, str, str]] = [
+    # Remaining concrete SDK 8 migration inventory (#911 comment)
+    ("AccountIdReference", "core.account_ref", "AccountReference1"),
+    ("InlineAccountReference", "core.account_ref", "AccountReference2"),
+    ("VendorPricingOptionUnion", "core.vendor_pricing_option", "VendorPricingOption"),
+    ("CpmVendorPricingOption", "core.vendor_pricing_option", "VendorPricingOption1"),
+    (
+        "PercentOfMediaVendorPricingOption",
+        "core.vendor_pricing_option",
+        "VendorPricingOption2",
+    ),
+    ("FlatFeeVendorPricingOption", "core.vendor_pricing_option", "VendorPricingOption3"),
+    ("PerUnitVendorPricingOption", "core.vendor_pricing_option", "VendorPricingOption4"),
+    ("CustomVendorPricingOption", "core.vendor_pricing_option", "VendorPricingOption5"),
+    ("ProductAllocation", "core.product_allocation", "ProductAllocation"),
+    ("TrustedMatch", "core.product", "TrustedMatch"),
+    ("SignalCoverageForecast", "core.signal_coverage_forecast", "SignalCoverageForecast"),
+    ("SignalCoverageRange", "signals.get_signals_response", "Range"),
+    ("MissingMetric", "core.missing_metric", "MissingMetric"),
+    (
+        "LegacyUpdateMediaBuyErrorResponse",
+        "media_buy.update_media_buy_response",
+        "UpdateMediaBuyResponse2",
+    ),
     # Creative — ListCreativesCreative deliberately remains the legacy
     # class-shaped alias for subclass compatibility. The 3.1.8 split also
     # exposes ListCreativesCanonicalCreative and ListCreativesCreativeItem.
diff --git a/tests/test_decisioning_serve.py b/tests/test_decisioning_serve.py
index d49ae81ff..158edc4e4 100644
--- a/tests/test_decisioning_serve.py
+++ b/tests/test_decisioning_serve.py
@@ -41,6 +41,8 @@
 from adcp.decisioning.serve import (
     serve as serve_platform,
 )
+from adcp.exceptions import ConfigurationError
+from adcp.server.mcp_tools import _resolve_handler_adcp_version
 
 
 class _BarePlatform(DecisioningPlatform):
@@ -140,6 +142,46 @@ def test_create_returns_handler_executor_registry_tuple() -> None:
     executor.shutdown(wait=True)
 
 
+def test_create_pins_handler_adcp_version() -> None:
+    handler, executor, _ = create_adcp_server_from_platform(_BarePlatform(), adcp_version="3.1")
+    try:
+        assert handler.get_adcp_version() == "3.1"
+        assert _resolve_handler_adcp_version(handler, None) == "3.1"
+        assert _resolve_handler_adcp_version(handler, "3.2") == "3.2"
+    finally:
+        executor.shutdown(wait=True)
+
+
+def test_create_pin_selects_versioned_mcp_discovery_schema() -> None:
+    from adcp.server.mcp_tools import get_tools_for_handler
+
+    handler, executor, _ = create_adcp_server_from_platform(
+        _BarePlatform(), adcp_version="3.1", advertise_all=True
+    )
+    try:
+        tools = {tool["name"]: tool for tool in get_tools_for_handler(handler, advertise_all=True)}
+        properties = tools["list_creatives"]["inputSchema"]["properties"]
+        assert "assignment_projection" not in properties
+        assert "assignment_limit" not in properties
+    finally:
+        executor.shutdown(wait=True)
+
+
+def test_create_defaults_to_packaged_adcp_version() -> None:
+    from adcp._version import resolve_adcp_version
+
+    handler, executor, _ = create_adcp_server_from_platform(_BarePlatform())
+    try:
+        assert handler.get_adcp_version() == resolve_adcp_version(None)
+    finally:
+        executor.shutdown(wait=True)
+
+
+def test_create_rejects_invalid_adcp_version() -> None:
+    with pytest.raises(ConfigurationError, match="adcp_version"):
+        create_adcp_server_from_platform(_BarePlatform(), adcp_version="invalid")
+
+
 def test_create_default_executor_uses_named_threads() -> None:
     """Framework-allocated default executor sets a thread_name_prefix
     for operator visibility (D5)."""
@@ -221,6 +263,7 @@ def test_serve_forwards_timed_sync_admission_limit() -> None:
     handler = MagicMock()
     executor = MagicMock()
     registry = MagicMock()
+    media_buy_store = MagicMock()
     decisioning_serve_module = importlib.import_module("adcp.decisioning.serve")
     server_serve_module = importlib.import_module("adcp.server.serve")
     with (
@@ -234,10 +277,14 @@ def test_serve_forwards_timed_sync_admission_limit() -> None:
         serve_platform(
             _BarePlatform(),
             timed_sync_get_products_limit=3,
+            media_buy_store=media_buy_store,
+            adcp_version="3.1",
             validate_at_init=False,
         )
 
     assert create.call_args.kwargs["timed_sync_get_products_limit"] == 3
+    assert create.call_args.kwargs["media_buy_store"] is media_buy_store
+    assert create.call_args.kwargs["adcp_version"] == "3.1"
     server_serve.assert_called_once()
 
 
diff --git a/tests/test_migrate_v3_to_v4.py b/tests/test_migrate_v3_to_v4.py
index af521ff83..6192fd0be 100644
--- a/tests/test_migrate_v3_to_v4.py
+++ b/tests/test_migrate_v3_to_v4.py
@@ -9,6 +9,7 @@
 
 from __future__ import annotations
 
+import importlib
 import json
 from pathlib import Path
 
@@ -239,7 +240,6 @@ def test_generated_poc_symbol_map_covers_publicly_exported_names() -> None:
     public-API symbol on ``adcp.types`` — otherwise the hint sends
     adopters to a NameError. Guards against drift between the codemod's
     map and the SDK's __all__."""
-    import importlib
 
     types_module = importlib.import_module("adcp.types")
     for symbol, replacement in v3_to_v4.GENERATED_POC_SYMBOL_MAP.items():
@@ -254,6 +254,15 @@ def test_generated_poc_symbol_map_covers_publicly_exported_names() -> None:
             "or add the public alias."
         )
 
+    for (_module, _symbol), replacement in v3_to_v4.GENERATED_POC_SOURCE_SYMBOL_MAP.items():
+        public_name = replacement.removeprefix("adcp.types.")
+        assert replacement == f"adcp.types.{public_name}"
+        assert hasattr(
+            types_module, public_name
+        ), f"source-scoped migration target {replacement!r} is not public"
+        source_module = importlib.import_module(f"adcp.types.generated_poc.{_module}")
+        assert getattr(types_module, public_name) is getattr(source_module, _symbol)
+
 
 def test_flags_removed_attribute_accesses(tmp_path: Path) -> None:
     """``.brand_manifest`` on ResolvedBrand was removed — flag the
@@ -673,6 +682,50 @@ def test_auto_apply_rewrites_all_known_private_import(tmp_path: Path) -> None:
     assert auto_applied[0].after == "adcp.types.ContextObject"
 
 
+def test_auto_apply_uses_source_scoped_semantic_alias(tmp_path: Path) -> None:
+    path = _write(
+        tmp_path,
+        "code.py",
+        "from adcp.types.generated_poc.core.vendor_pricing_option import "
+        "VendorPricingOption1\n"
+        "option: VendorPricingOption1\n",
+    )
+    v3_to_v4.run(tmp_path, apply_changes=True, auto_apply=True)
+
+    rewritten = path.read_text()
+    assert rewritten == (
+        "from adcp.types import CpmVendorPricingOption as VendorPricingOption1\n"
+        "option: VendorPricingOption1\n"
+    )
+    compile(rewritten, str(path), "exec")
+
+
+def test_auto_apply_preserves_crlf_after_source_scoped_import(tmp_path: Path) -> None:
+    path = tmp_path / "code.py"
+    path.write_bytes(
+        b"from adcp.types.generated_poc.core.vendor_pricing_option import "
+        b"VendorPricingOption1\r\noption = VendorPricingOption1\r\n"
+    )
+    v3_to_v4.run(tmp_path, apply_changes=True, auto_apply=True)
+
+    rewritten = path.read_bytes()
+    assert rewritten == (
+        b"from adcp.types import CpmVendorPricingOption as VendorPricingOption1\r\n"
+        b"option = VendorPricingOption1\r\n"
+    )
+    compile(rewritten, str(path), "exec")
+
+
+def test_auto_apply_does_not_guess_colliding_source_variant(tmp_path: Path) -> None:
+    path = _write(
+        tmp_path,
+        "code.py",
+        "from adcp.types.generated_poc.core.product_filters import TrustedMatch\n",
+    )
+    v3_to_v4.run(tmp_path, apply_changes=True, auto_apply=True)
+    assert "adcp.types.generated_poc.core.product_filters" in path.read_text()
+
+
 def test_auto_apply_rewrites_multi_symbol_all_known_line(tmp_path: Path) -> None:
     """A single import line with multiple known symbols is rewritten in one shot."""
     path = _write(
diff --git a/tests/test_testing_decisioning.py b/tests/test_testing_decisioning.py
index 846f5026d..9183b21ee 100644
--- a/tests/test_testing_decisioning.py
+++ b/tests/test_testing_decisioning.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
+from typing import Literal
 
 import httpx
 import pytest
@@ -320,12 +321,15 @@ async def _run() -> int:
     assert asyncio.run(_run()) == 200
 
 
-def test_build_asgi_app_discovery_endpoint_absent_by_default() -> None:
+@pytest.mark.parametrize("transport", ["mcp", "a2a", "both"])
+def test_build_asgi_app_discovery_endpoint_absent_by_default(
+    transport: Literal["mcp", "a2a", "both"],
+) -> None:
     """Without ``discovery_base_url=``, the well-known path returns 404."""
     import asyncio
 
     platform = _SalesPlatformWithMethods()
-    app = build_asgi_app(platform, allowed_hosts=["test"])
+    app = build_asgi_app(platform, transport=transport, allowed_hosts=["test"])
 
     async def _run() -> int:
         import httpx
@@ -384,6 +388,92 @@ async def test_build_asgi_app_path_normalize_applied() -> None:
     assert resp.status_code == 200
 
 
+async def test_build_asgi_app_both_routes_mcp_and_a2a() -> None:
+    """The unified helper exposes MCP at ``/mcp`` and A2A at the root."""
+    import asyncio as _asyncio
+
+    from asgi_lifespan import LifespanManager
+
+    app = await _asyncio.to_thread(
+        build_asgi_app,
+        _SalesPlatformWithMethods(),
+        transport="both",
+        allowed_hosts=["test"],
+    )
+    async with LifespanManager(app):
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://test"
+        ) as client:
+            mcp = await client.post(
+                "/mcp",
+                json={
+                    "jsonrpc": "2.0",
+                    "id": 0,
+                    "method": "initialize",
+                    "params": {
+                        "protocolVersion": "2025-06-18",
+                        "capabilities": {},
+                        "clientInfo": {"name": "test", "version": "1.0"},
+                    },
+                },
+                headers={
+                    "content-type": "application/json",
+                    "accept": "application/json, text/event-stream",
+                },
+            )
+            agent_card = await client.get("/.well-known/agent.json")
+
+    assert mcp.status_code == 200
+    assert agent_card.status_code == 200
+
+
+async def test_build_asgi_app_both_discovery_lists_both_transports() -> None:
+    import asyncio as _asyncio
+
+    app = await _asyncio.to_thread(
+        build_asgi_app,
+        _SalesPlatformWithMethods(),
+        transport="both",
+        allowed_hosts=["test"],
+        discovery_base_url="http://127.0.0.1",
+    )
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        response = await client.get("/.well-known/adcp-agents.json")
+
+    assert response.status_code == 200
+    assert {agent["transport"] for agent in response.json()["agents"]} == {"mcp", "a2a"}
+
+
+async def test_build_test_client_both_applies_auth_to_both_legs() -> None:
+    from adcp.server.auth import BearerTokenAuth
+
+    auth = BearerTokenAuth(validate_token=lambda token: token == "tok_test")
+    async with build_test_client(
+        _SalesPlatformWithMethods(), transport="both", auth=auth
+    ) as client:
+        mcp = await client.post(
+            "/mcp",
+            json={
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/call",
+                "params": {"name": "get_products", "arguments": {}},
+            },
+            headers={
+                "content-type": "application/json",
+                "accept": "application/json, text/event-stream",
+            },
+        )
+        a2a = await client.post("/", json={})
+        agent_card = await client.get("/.well-known/agent.json")
+
+    assert mcp.status_code == 401
+    assert a2a.status_code == 401
+    assert agent_card.status_code == 200
+
+
 # ---- build_test_client: new serve-layer kwargs ----
 
 
diff --git a/tests/test_version_scoped_models.py b/tests/test_version_scoped_models.py
index 090c9856d..29e02ec24 100644
--- a/tests/test_version_scoped_models.py
+++ b/tests/test_version_scoped_models.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 from jsonschema.validators import validator_for
 from pydantic import TypeAdapter, ValidationError
@@ -15,6 +17,7 @@
 )
 from adcp.server.mcp_tools import get_tools_for_handler
 from adcp.types.v31 import BuildCreativeSubmittedResponse
+from adcp.types.v31 import CreateMediaBuyResponse as CreateMediaBuyResponse31
 from adcp.types.v31 import GetBrandIdentityRequest as GetBrandIdentityRequest31
 from adcp.types.v31 import ListCreativesRequest as ListCreativesRequest31
 from adcp.types.v31 import PackageRequest as PackageRequest31
@@ -22,6 +25,8 @@
 from adcp.types.v32 import PackageRequest as PackageRequest32
 from adcp.validation import get_mcp_schema, get_validator
 
+ROOT = Path(__file__).parents[1]
+
 
 def test_list_creatives_schema_is_version_scoped() -> None:
     schema31 = ListCreativesRequest31.model_json_schema()
@@ -38,6 +43,7 @@ def test_package_budget_requirement_is_version_scoped() -> None:
         PackageRequest31(product_id="product-1", pricing_option_id="fixed")
 
     package32 = PackageRequest32(product_id="product-1", pricing_option_id="fixed")
+    assert package32.budget is None
     assert package32.model_dump() == {
         "product_id": "product-1",
         "pricing_option_id": "fixed",
@@ -47,6 +53,46 @@ def test_package_budget_requirement_is_version_scoped() -> None:
     assert "budget" not in PackageRequest32.model_json_schema()["required"]
 
 
+def test_union_response_fields_are_available_with_optional_attribute_semantics() -> None:
+    response = CreateMediaBuyResponse31(
+        status="failed",
+        errors=[{"code": "INVALID_REQUEST", "message": "bad request"}],
+    )
+    assert response.errors[0]["code"] == "INVALID_REQUEST"
+    assert response.media_buy_id is None
+
+
+def test_union_success_status_preserves_all_of_intersection() -> None:
+    with pytest.raises(ValidationError):
+        CreateMediaBuyResponse31(
+            status="active",
+            media_buy_id="buy-1",
+            confirmed_at=None,
+            revision=1,
+            packages=[],
+        )
+
+    response = CreateMediaBuyResponse31(
+        status="completed",
+        media_buy_id="buy-1",
+        confirmed_at=None,
+        revision=1,
+        packages=[],
+    )
+    assert response.status == "completed"
+
+
+def test_generated_stubs_preserve_nested_all_of_requiredness() -> None:
+    stub = (ROOT / "src" / "adcp" / "types" / "v31.pyi").read_text()
+    metrics_start = stub.index(
+        "class _ExternalCoreSignalCoverageForecastPointsItemMetrics(TypedDict"
+    )
+    metrics_end = stub.index("\n\n", metrics_start)
+    metrics = stub[metrics_start:metrics_end]
+
+    assert "coverage_rate: Required[" in metrics
+
+
 def test_versioned_models_keep_generated_model_ergonomics() -> None:
     request = ListCreativesRequest31(include_assignments=True)
     assert request.include_assignments is True
diff --git a/tests/type_checks/versioned_types.py b/tests/type_checks/versioned_types.py
new file mode 100644
index 000000000..c969996fb
--- /dev/null
+++ b/tests/type_checks/versioned_types.py
@@ -0,0 +1,118 @@
+"""Static contract for the generated version-scoped model stubs."""
+
+from typing import Literal
+
+from typing_extensions import assert_type
+
+from adcp.types.v31 import BuildCreativeRequest as BuildCreativeRequest31
+from adcp.types.v31 import CreateMediaBuyResponse as CreateMediaBuyResponse31
+from adcp.types.v31 import GetBrandIdentityResponse as GetBrandIdentityResponse31
+from adcp.types.v31 import GetSignalsResponse as GetSignalsResponse31
+from adcp.types.v31 import ListCreativesRequest as ListCreativesRequest31
+from adcp.types.v31 import PackageRequest as PackageRequest31
+from adcp.types.v32 import AcceptProposalRequest as AcceptProposalRequest32
+from adcp.types.v32 import AcceptProposalResponse as AcceptProposalResponse32
+from adcp.types.v32 import BuyProductsResponse as BuyProductsResponse32
+from adcp.types.v32 import ListCreativesRequest as ListCreativesRequest32
+from adcp.types.v32 import PackageRequest as PackageRequest32
+
+list_request31 = ListCreativesRequest31(include_assignments=True)
+assert_type(list_request31.include_assignments, bool)
+ListCreativesRequest31(context={"trace_id": "trace-1"})
+ListCreativesRequest31(account={"account_id": "account-1"})
+ListCreativesRequest31(account={"brand": {"domain": "example.com"}, "operator": "agency.example"})
+BuildCreativeRequest31(
+    idempotency_key="build-1",
+    signal_conditions=[
+        {
+            "value_type": "binary",
+            "value": True,
+            "signal_ref": {"scope": "product", "signal_id": "weather"},
+            "signal_agent_segment_id": "segment-1",
+        }
+    ],
+)
+
+list_request32 = ListCreativesRequest32(assignment_projection="matching", assignment_limit=10)
+assert_type(list_request32.assignment_projection, Literal["all", "matching"])
+assert_type(list_request32.assignment_limit, int)
+
+package31 = PackageRequest31(
+    product_id="product-1",
+    pricing_option_id="fixed",
+    budget=100.0,
+)
+assert_type(package31.budget, float)
+
+# Budget is optional in 3.2, and the constructor signature preserves that
+# version delta for type checkers.
+package32 = PackageRequest32(product_id="product-1", pricing_option_id="fixed")
+assert_type(package32.budget, float | None)
+
+success_response31 = CreateMediaBuyResponse31(
+    status="completed",
+    media_buy_id="buy-1",
+    confirmed_at=None,
+    revision=1,
+    packages=[],
+)
+assert success_response31.media_buy_id is not None
+assert_type(success_response31.media_buy_id, str)
+
+error_response31 = CreateMediaBuyResponse31(
+    status="failed",
+    errors=[{"code": "INVALID_REQUEST", "message": "bad request"}],
+)
+assert error_response31.errors is not None
+assert_type(error_response31.errors[0]["code"], str)
+
+signals_response31 = GetSignalsResponse31(
+    status="completed",
+    signals=[],
+)
+assert signals_response31.signals is not None
+assert_type(signals_response31.signals[0]["name"], str)
+coverage_point31 = signals_response31.signals[0]["coverage_forecast"]["points"][0]
+assert_type(coverage_point31["metrics"]["coverage_rate"]["mid"], float)
+assert_type(
+    coverage_point31["dimensions"][0]["kind"],
+    Literal["geo", "placement", "device_type", "device_platform", "audience", "signal"],
+)
+
+brand_response31 = GetBrandIdentityResponse31(
+    status="completed",
+    brand_id="brand-1",
+    house={"domain": "example.com", "name": "Example"},
+    names=[],
+    fonts={"primary": "Inter"},
+)
+assert brand_response31.fonts is not None
+primary_font31 = brand_response31.fonts["primary"]
+if isinstance(primary_font31, str):
+    assert_type(primary_font31, str)
+else:
+    assert_type(primary_font31["family"], str)
+
+accept_error32 = AcceptProposalResponse32(
+    status="failed",
+    errors=[{"code": "INVALID_REQUEST", "message": "bad request"}],
+)
+assert accept_error32.errors is not None
+assert_type(accept_error32.errors[0]["message"], str)
+
+buy_error32 = BuyProductsResponse32(
+    status="failed",
+    errors=[{"code": "INVALID_REQUEST", "message": "bad request"}],
+)
+assert buy_error32.errors is not None
+assert_type(buy_error32.errors[0]["message"], str)
+
+accept_request32 = AcceptProposalRequest32(
+    adcp_version="3.2-beta.0",
+    idempotency_key="accept-1",
+    account={},
+    proposal_id="proposal-1",
+    proposal_terms_digest="sha256:terms",
+)
+assert accept_request32.adcp_version is not None
+assert_type(accept_request32.adcp_version, str)