@adcp/sdk 14.0.0-rc.38 → 14.0.0-rc.39

package/dist/lib/media-buy/preflight.mjs

@@ -1,6 +1,35 @@
 import { ValidationError } from "../errors/index.mjs";
-import { findAvailableAction, getAvailableActions } from "./available-actions.mjs";
-import { ACTIONS_BY_FIELD } from "./update-fields.generated.mjs";
+import {
+  withActionProposal,
+  liveActionIssues,
+  liveActionFitsVersion,
+  mediaBuyActionTasks,
+  packageActionStatus,
+  actionAllowedStatuses
+} from "./action-contracts.mjs";
+import { assessActionAvailability } from "./action-assessment.mjs";
+import {
+  findAvailableAction,
+  getAvailableActions,
+  getRollupParent
+} from "./available-actions.mjs";
+import { CANONICAL_ACTION_TASKS } from "./action-metadata.generated.mjs";
+import {
+  decomposeUpdateMediaBuy,
+  hasUnmappedMutation
+} from "./mutations.mjs";
+export * from "./mutations.mjs";
+function tasksForLegacyMutation(action) {
+  const direct = mediaBuyActionTasks(action);
+  if (direct.length) return direct;
+  const children = Object.keys(CANONICAL_ACTION_TASKS).filter(
+    (child) => getRollupParent(child) === action
+  );
+  if (!children.length) return [];
+  return mediaBuyActionTasks(children[0]).filter(
+    (task) => children.every((child) => mediaBuyActionTasks(child).includes(task))
+  );
+}
 function isAvailable(buy, action) {
   return findAvailableAction(buy, action, { silent: true }) !== void 0;
 }
@@ -21,340 +50,23 @@ const canUpdateCreativeAssignments = (buy) => isAvailable(buy, "update_creative_
 const canAddPackages = (buy) => isAvailable(buy, "add_packages");
 const canRemovePackages = (buy) => isAvailable(buy, "remove_packages");
 const canRemoveCreative = (buy) => isAvailable(buy, "remove_creative");
-const BUDGET_EQUAL_TOLERANCE = 5e-3;
-function getActionForMutation(currentBuy, request) {
-  return decomposeUpdateMediaBuy(currentBuy, request).actions;
-}
-function decomposeUpdateMediaBuy(currentBuy, request) {
-  const mutations = [];
-  const currentPackages = /* @__PURE__ */ new Map();
-  for (const pkg of currentBuy.packages ?? []) {
-    if (pkg.package_id) currentPackages.set(pkg.package_id, pkg);
-  }
-  const push = (mutation) => {
-    mutations.push(mutation);
-  };
-  if (request.paused !== void 0) {
-    push({
-      action: request.paused === false ? "resume" : "pause",
-      field: "paused",
-      path: "paused",
-      scope: "buy",
-      to: request.paused
-    });
-  }
-  if (request.canceled !== void 0) {
-    push({
-      action: "cancel",
-      field: "canceled",
-      path: "canceled",
-      scope: "buy",
-      to: request.canceled
-    });
-  }
-  if (request.cancellation_reason !== void 0) {
-    push({
-      action: "cancel",
-      field: "cancellation_reason",
-      path: "cancellation_reason",
-      scope: "buy",
-      to: request.cancellation_reason
-    });
-  }
-  if (request.start_time !== void 0) {
-    push({
-      action: "update_flight_dates",
-      direction: "shift",
-      field: "start_time",
-      path: "start_time",
-      scope: "buy",
-      from: currentBuy.start_time,
-      to: request.start_time
-    });
-  }
-  if (request.end_time !== void 0) {
-    const pick = resolveFlightEndDirection(currentBuy, request, "end_time");
-    push({
-      ...pick,
-      field: "end_time",
-      path: "end_time",
-      scope: "buy",
-      from: currentBuy.end_time,
-      to: request.end_time
-    });
-  }
-  if (request.frequency_cap !== void 0) {
-    const [frequencyCapAction] = ACTIONS_BY_FIELD["frequency_cap"] ?? [];
-    if (frequencyCapAction) {
-      push({
-        action: frequencyCapAction,
-        field: "frequency_cap",
-        path: "frequency_cap",
-        scope: "buy",
-        to: request.frequency_cap
-      });
-    }
-  }
-  if (request.new_packages !== void 0 && request.new_packages.length > 0) {
-    push({
-      action: "add_packages",
-      field: "new_packages",
-      path: "new_packages",
-      scope: "packages",
-      to: request.new_packages
-    });
-  }
-  if (request.packages) {
-    const budgetPick = resolveBudgetDirection(currentBuy, request);
-    const packageEndPick = resolveFlightEndDirection(currentBuy, request, "packages[].end_time");
-    request.packages.forEach((pkg, index) => {
-      const currentPkg = currentPackages.get(pkg.package_id);
-      const base = {
-        scope: "package",
-        package_id: pkg.package_id,
-        package_index: index
-      };
-      if (pkg.canceled !== void 0) {
-        push({
-          action: "remove_packages",
-          field: "packages[].canceled",
-          path: `packages[${index}].canceled`,
-          ...base,
-          to: pkg.canceled
-        });
-      }
-      if (pkg.budget !== void 0) {
-        push({
-          ...budgetPick,
-          field: "packages[].budget",
-          path: `packages[${index}].budget`,
-          ...base,
-          from: currentPkg?.budget,
-          to: pkg.budget
-        });
-      }
-      if (pkg.pacing !== void 0) {
-        push({
-          action: "update_pacing",
-          field: "packages[].pacing",
-          path: `packages[${index}].pacing`,
-          ...base,
-          to: pkg.pacing
-        });
-      }
-      if (pkg.start_time !== void 0) {
-        push({
-          action: "update_flight_dates",
-          direction: "shift",
-          field: "packages[].start_time",
-          path: `packages[${index}].start_time`,
-          ...base,
-          from: currentPkg?.start_time,
-          to: pkg.start_time
-        });
-      }
-      if (pkg.end_time !== void 0) {
-        push({
-          ...packageEndPick,
-          field: "packages[].end_time",
-          path: `packages[${index}].end_time`,
-          ...base,
-          from: currentPkg?.end_time,
-          to: pkg.end_time
-        });
-      }
-      if (pkg.creative_assignments !== void 0) {
-        push({
-          action: "update_creative_assignments",
-          field: "packages[].creative_assignments",
-          path: `packages[${index}].creative_assignments`,
-          ...base,
-          to: pkg.creative_assignments
-        });
-      }
-      if (pkg.creatives !== void 0) {
-        push({
-          action: "replace_creative",
-          field: "packages[].creatives",
-          path: `packages[${index}].creatives`,
-          ...base,
-          to: pkg.creatives
-        });
-      }
-      if (pkg.keyword_targets_add !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].keyword_targets_add",
-          path: `packages[${index}].keyword_targets_add`,
-          ...base,
-          to: pkg.keyword_targets_add
-        });
-      }
-      if (pkg.keyword_targets_remove !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].keyword_targets_remove",
-          path: `packages[${index}].keyword_targets_remove`,
-          ...base,
-          to: pkg.keyword_targets_remove
-        });
-      }
-      if (pkg.negative_keywords_add !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].negative_keywords_add",
-          path: `packages[${index}].negative_keywords_add`,
-          ...base,
-          to: pkg.negative_keywords_add
-        });
-      }
-      if (pkg.negative_keywords_remove !== void 0) {
-        push({
-          action: "update_targeting",
-          field: "packages[].negative_keywords_remove",
-          path: `packages[${index}].negative_keywords_remove`,
-          ...base,
-          to: pkg.negative_keywords_remove
-        });
-      }
-      if (pkg.targeting_overlay !== void 0) {
-        const overlayKeys = Object.keys(pkg.targeting_overlay);
-        if (overlayKeys.length === 1 && overlayKeys[0] === "frequency_cap") {
-          push({
-            action: "update_frequency_caps",
-            field: "packages[].targeting_overlay.frequency_cap",
-            path: `packages[${index}].targeting_overlay.frequency_cap`,
-            ...base,
-            to: pkg.targeting_overlay.frequency_cap
-          });
-        } else {
-          push({
-            action: "update_targeting",
-            field: "packages[].targeting_overlay",
-            path: `packages[${index}].targeting_overlay`,
-            ...base,
-            to: pkg.targeting_overlay
-          });
-        }
-      }
-    });
-  }
-  return {
-    mutations,
-    actions: aggregateResolvedActions(mutations),
-    touched_fields: uniqueFields(mutations)
-  };
-}
-function aggregateResolvedActions(mutations) {
-  const resolved = /* @__PURE__ */ new Map();
-  for (const mutation of mutations) {
-    const existing = resolved.get(mutation.action);
-    if (existing) {
-      if (existing.direction === void 0 && mutation.direction !== void 0) {
-        existing.direction = mutation.direction;
-      }
-      if (!existing.touched_fields.includes(mutation.field)) {
-        existing.touched_fields.push(mutation.field);
-      }
-      continue;
-    }
-    resolved.set(mutation.action, {
-      action: mutation.action,
-      direction: mutation.direction,
-      touched_fields: [mutation.field]
-    });
-  }
-  return [...resolved.values()];
-}
-function uniqueFields(mutations) {
-  const fields = [];
-  for (const mutation of mutations) {
-    if (!fields.includes(mutation.field)) fields.push(mutation.field);
-  }
-  return fields;
-}
-function resolveBudgetDirection(currentBuy, request) {
-  const currentByPkg = /* @__PURE__ */ new Map();
-  for (const pkg of currentBuy.packages ?? []) {
-    if (pkg.package_id && typeof pkg.budget === "number") {
-      currentByPkg.set(pkg.package_id, pkg.budget);
-    }
-  }
-  let currentTotal = 0;
-  let proposedTotal = 0;
-  let sawIncrease = false;
-  let sawDecrease = false;
-  for (const pkg of request.packages ?? []) {
-    if (typeof pkg.budget !== "number") continue;
-    const prev = currentByPkg.get(pkg.package_id);
-    if (prev === void 0) {
-      sawIncrease = true;
-      proposedTotal += pkg.budget;
-      continue;
-    }
-    currentTotal += prev;
-    proposedTotal += pkg.budget;
-    if (pkg.budget > prev) sawIncrease = true;
-    if (pkg.budget < prev) sawDecrease = true;
-  }
-  if (sawIncrease && sawDecrease && Math.abs(proposedTotal - currentTotal) < BUDGET_EQUAL_TOLERANCE) {
-    return { action: "reallocate_budget", direction: "reallocate" };
-  }
-  if (proposedTotal > currentTotal) return { action: "increase_budget", direction: "increase" };
-  if (proposedTotal < currentTotal) return { action: "decrease_budget", direction: "decrease" };
-  return { action: "reallocate_budget", direction: "reallocate" };
-}
-function resolveFlightEndDirection(currentBuy, request, field) {
-  if (request.start_time !== void 0) {
-    return { action: "update_flight_dates", direction: "shift" };
-  }
-  const packageStartTouched = (request.packages ?? []).some((pkg) => pkg.start_time !== void 0);
-  if (packageStartTouched) {
-    return { action: "update_flight_dates", direction: "shift" };
-  }
-  if (field === "end_time") {
-    const currentEnd = currentBuy.end_time;
-    const proposedEnd = request.end_time;
-    if (currentEnd && proposedEnd) {
-      const cur = Date.parse(currentEnd);
-      const next = Date.parse(proposedEnd);
-      if (!Number.isNaN(cur) && !Number.isNaN(next)) {
-        if (next > cur) return { action: "extend_flight", direction: "extend" };
-        if (next < cur) return { action: "shorten_flight", direction: "shorten" };
-      }
-    }
-    return { action: "update_flight_dates", direction: "shift" };
-  }
-  let extending = false;
-  let shortening = false;
-  const currentByPkg = /* @__PURE__ */ new Map();
-  for (const pkg of currentBuy.packages ?? []) {
-    if (pkg.package_id) currentByPkg.set(pkg.package_id, pkg.end_time);
-  }
-  for (const pkg of request.packages ?? []) {
-    if (!pkg.end_time) continue;
-    const prev = currentByPkg.get(pkg.package_id);
-    if (!prev) {
-      extending = true;
-      continue;
-    }
-    const cur = Date.parse(prev);
-    const next = Date.parse(pkg.end_time);
-    if (Number.isNaN(cur) || Number.isNaN(next)) continue;
-    if (next > cur) extending = true;
-    if (next < cur) shortening = true;
-  }
-  if (extending && !shortening) return { action: "extend_flight", direction: "extend" };
-  if (shortening && !extending) return { action: "shorten_flight", direction: "shorten" };
-  return { action: "update_flight_dates", direction: "shift" };
-}
-function preflightUpdateMediaBuy(currentBuy, request) {
+function preflightUpdateMediaBuy(currentBuy, request, options = {}) {
+  const assessmentBuy = currentBuy;
+  currentBuy = withActionProposal(currentBuy, options);
+  options = { ...options, task: options.task ?? "update_media_buy" };
   const decomposition = decomposeUpdateMediaBuy(currentBuy, request);
   const resolved = decomposition.actions;
+  const strict = currentBuy.accepted_proposal?.commercial_terms?.change_terms !== void 0 || currentBuy.available_actions?.some((entry) => entry?.change_term_id !== void 0) === true;
+  if (hasUnmappedMutation(request, decomposition))
+    throw new ValidationError(
+      "request",
+      void 0,
+      "At least one requested mutation has no supported action mapping; do not submit a partial mutation."
+    );
   if (resolved.length === 0) {
     throw new ValidationError(
       "request",
-      request,
+      void 0,
       "update_media_buy request must touch at least one mutating field (paused, canceled, start_time, end_time, frequency_cap, packages[*], or new_packages)"
     );
   }
@@ -364,14 +76,77 @@ function preflightUpdateMediaBuy(currentBuy, request) {
   const modes = [];
   const denials = [];
   for (const resolvedAction of resolved) {
+    if (!strict && (resolvedAction.action === "pause" || resolvedAction.action === "resume")) {
+      const controls = decomposition.mutations.filter(
+        (mutation) => mutation.action === resolvedAction.action && mutation.field === "packages[].paused"
+      );
+      if (controls.length) {
+        const statuses = controls.map(
+          (mutation) => packageActionStatus(currentBuy.packages?.find((pkg) => pkg.package_id === mutation.package_id))
+        );
+        const allowed = actionAllowedStatuses({ action: resolvedAction.action });
+        if (currentBuy.status === void 0 || statuses.some((status) => status === void 0)) {
+          denials.push({ action: resolvedAction.action, reason: "condition_unresolved" });
+          continue;
+        }
+        if (!["active", "paused"].includes(currentBuy.status) || statuses.some((status) => !allowed.includes(status))) {
+          denials.push({ action: resolvedAction.action, reason: "wrong_status" });
+          continue;
+        }
+      }
+    }
+    if (strict || options.proposal !== void 0 || resolvedAction.action === "update_name") {
+      const assessment = assessActionAvailability(assessmentBuy, resolvedAction.action, { ...options, request });
+      if (assessment.status === "currently_unavailable") {
+        denials.push({ action: resolvedAction.action, reason: assessment.reason, assessment });
+        continue;
+      }
+    }
     const lookup = findAvailableAction(currentBuy, resolvedAction.action, { silent: true });
     if (!lookup) {
       denials.push({ action: resolvedAction.action, reason: "not_supported_on_buy" });
       continue;
     }
+    if (options.adcpVersion && !liveActionFitsVersion(lookup.entry, options.adcpVersion)) {
+      denials.push({
+        action: resolvedAction.action,
+        reason: "condition_unresolved",
+        assessment: {
+          status: "currently_unavailable",
+          action: resolvedAction.action,
+          reason: "condition_unresolved",
+          certainty: "unknown",
+          message: "The action uses metadata introduced after the supplied seller version."
+        }
+      });
+      continue;
+    }
+    if (!strict && lookup.entry.task !== void 0 && !tasksForLegacyMutation(resolvedAction.action).includes(lookup.entry.task)) {
+      denials.push({ action: resolvedAction.action, reason: "mode_mismatch" });
+      continue;
+    }
+    if (!strict && lookup.entry.applicable_package_ids !== void 0) {
+      const scoped = decomposition.mutations.filter((m) => m.action === resolvedAction.action);
+      const ids = lookup.entry.applicable_package_ids;
+      if (liveActionIssues([lookup.entry]).length || !scoped.length) {
+        denials.push({ action: resolvedAction.action, reason: "condition_unresolved" });
+        continue;
+      }
+      if (scoped.some((m) => m.scope !== "package" || !m.package_id || !ids.includes(m.package_id))) {
+        denials.push({ action: resolvedAction.action, reason: "not_supported_on_buy" });
+        continue;
+      }
+    }
+    if (!strict && options.task !== "update_media_buy" && options.task !== (lookup.entry.task ?? "update_media_buy")) {
+      denials.push({ action: resolvedAction.action, reason: "mode_mismatch" });
+      continue;
+    }
     matched.push(lookup.entry);
     modes.push(lookup.entry.mode);
   }
+  if (strict && options.task !== "update_media_buy" && denials.length === 0 && new Set(matched.map((entry) => entry.task ?? "update_media_buy")).size > 1) {
+    for (const action of resolved) denials.push({ action: action.action, reason: "mode_mismatch" });
+  }
   if (denials.length > 0) {
     return {
       ok: false,
@@ -395,6 +170,11 @@ function recoveryForModeMismatch(attemptedAction, currentlyAvailable) {
   const entry = currentlyAvailable.find((a) => a.action === attemptedAction);
   if (!entry) return void 0;
   switch (entry.mode) {
+    case "seller_managed":
+      return {
+        kind: "waitForTask",
+        message: "Use the declared task and follow its submitted/working/completed lifecycle."
+      };
     case "requires_proposal":
       return {
         kind: "createProposal",
@@ -437,8 +217,6 @@ export {
   canUpdateFrequencyCaps,
   canUpdatePacing,
   canUpdateTargeting,
-  decomposeUpdateMediaBuy,
-  getActionForMutation,
   preflightUpdateMediaBuy,
   recoveryForModeMismatch
 };

package/dist/lib/media-buy/targeting-input.d.mts

@@ -29,8 +29,9 @@
  * rather than silently retaining the default.
  */
 /**
- * Strict effective overlay derived from a request-only Targeting Input: the
- * same dimensions, with the `null` clear command removed from each.
+ * Strict overlay projection derived from a request-only Targeting Input: the
+ * same dimensions, with the `null` clear command removed from each. This does
+ * not materialize configured-product defaults omitted by a create request.
  *
  * Generic rather than hardcoded to the generated `TargetingOverlay` because
  * the per-tool payload types widen non-empty-array tuples (`[string,
@@ -56,8 +57,10 @@ export type TargetingInputFor<T> = {
  * Resolve a request-only Targeting Input into the strict effective overlay,
  * dropping every `null` clear command.
  *
- * Use this on the **create** path, and whenever a request-shaped overlay is
- * about to become an accepted snapshot, a readback value, or durable state.
+ * Use this on the **create** path only when no configured/product targeting
+ * defaults need to be materialized. Otherwise pass those strict defaults and
+ * the request to {@link applyTargetingInput}. Also use this projection whenever
+ * a request-shaped overlay without a baseline is about to become strict state.
  *
  * Returns `undefined` when the input is absent, is an explicit whole-overlay
  * clear, or resolves to no surviving dimensions — a cleared dimension is absent

package/dist/lib/media-buy/targeting-input.d.ts

@@ -29,8 +29,9 @@
  * rather than silently retaining the default.
  */
 /**
- * Strict effective overlay derived from a request-only Targeting Input: the
- * same dimensions, with the `null` clear command removed from each.
+ * Strict overlay projection derived from a request-only Targeting Input: the
+ * same dimensions, with the `null` clear command removed from each. This does
+ * not materialize configured-product defaults omitted by a create request.
  *
  * Generic rather than hardcoded to the generated `TargetingOverlay` because
  * the per-tool payload types widen non-empty-array tuples (`[string,
@@ -56,8 +57,10 @@ export type TargetingInputFor<T> = {
  * Resolve a request-only Targeting Input into the strict effective overlay,
  * dropping every `null` clear command.
  *
- * Use this on the **create** path, and whenever a request-shaped overlay is
- * about to become an accepted snapshot, a readback value, or durable state.
+ * Use this on the **create** path only when no configured/product targeting
+ * defaults need to be materialized. Otherwise pass those strict defaults and
+ * the request to {@link applyTargetingInput}. Also use this projection whenever
+ * a request-shaped overlay without a baseline is about to become strict state.
  *
  * Returns `undefined` when the input is absent, is an explicit whole-overlay
  * clear, or resolves to no surviving dimensions — a cleared dimension is absent

package/dist/lib/media-buy/types.d.mts

@@ -1,20 +1,23 @@
 export type { ActionNotAllowedDetails, ActionNotAllowedReason, MediaBuyActionMode, MediaBuyAvailableAction, MediaBuyValidAction, SLAWindow, } from '../types/core.generated.mjs';
 import type { MediaBuyAvailableAction, MediaBuyValidAction } from '../types/core.generated.mjs';
 import type { SLAWindow } from '../types/core.generated.mjs';
+import type { ControlMediaBuyRequest } from '../types/tools.generated.mjs';
 import type { MediaBuyUpdateFieldAction } from './update-fields.generated.mjs';
+import type { CANONICAL_ACTION_TASKS } from './action-metadata.generated.mjs';
 /**
  * Every action id the structured `available_actions[].action` surface can
  * carry. Derived from the generated wire type plus the generated
- * `update_media_buy` dispatch table, so it is exactly the legacy
- * `MediaBuyValidAction` enum on schema pins that predate
+ * `update_media_buy` dispatch table, preserving the legacy vocabulary on schema pins that predate
  * `core/media-buy-available-action-id.json` (AdCP <= 3.2.0-rc.2) and widens
  * to include structured-only ids such as `update_media_buy_frequency_cap`
- * once the pin picks that schema up. Use this — not `MediaBuyValidAction` —
+ * once the pin picks that schema up. Canonical task metadata keeps the union
+ * narrow even when a generated oneOf wire type flattens action to string.
+ * Use this — not `MediaBuyValidAction` —
  * wherever code reads `available_actions[].action`, `allowed_actions[].action`,
  * or `ACTION_NOT_ALLOWED.attempted_action`. `MediaBuyValidAction` remains the
  * correct type for the deprecated flat `valid_actions[]` list only.
  */
-export type MediaBuyActionId = MediaBuyAvailableAction['action'] | MediaBuyUpdateFieldAction;
+export type MediaBuyActionId = MediaBuyAvailableAction['action'] | MediaBuyUpdateFieldAction | keyof typeof CANONICAL_ACTION_TASKS;
 /**
  * @deprecated Use `SLAWindow`. Kept as an import-compatibility alias for the
  * pre-codegen draft export name; the shape is the generated wire contract.
@@ -36,17 +39,31 @@ export type LegacyCoarseAction = (typeof LEGACY_COARSE_ACTIONS)[number];
  * fields are required by the helpers themselves.
  */
 export interface MediaBuyActionContext {
+    accepted_proposal?: import('./action-types.mjs').ActionProposal;
+    accepted_proposal_id?: string;
     media_buy_id?: string;
     status?: string;
     start_time?: string;
     end_time?: string;
+    revision?: number;
+    currency?: string;
+    total_budget?: number | {
+        amount: number;
+        currency: string;
+    };
+    daily_budget_cap?: number | null;
     packages?: ReadonlyArray<{
         package_id?: string;
         budget?: number;
         start_time?: string;
         end_time?: string;
+        canceled?: boolean;
+        paused?: boolean;
+        status?: string;
+        daily_budget_cap?: number | null;
+        min_spend_target?: number | null;
     }>;
-    available_actions?: MediaBuyAvailableAction[];
+    available_actions?: readonly import('./action-types.mjs').LiveMediaBuyAction[];
     valid_actions?: MediaBuyValidAction[];
 }
 /**
@@ -56,6 +73,26 @@ export interface MediaBuyActionContext {
  * resolver signature.
  */
 export interface UpdateMediaBuyRequestLike {
+    media_buy_id?: string;
+    account?: unknown;
+    context?: unknown;
+    governance_context?: unknown;
+    push_notification_config?: unknown;
+    ext?: unknown;
+    budget_cap_timezone?: string | null;
+    invoice_recipient?: unknown;
+    revision?: number;
+    idempotency_key?: string;
+    name?: string;
+    total_budget?: {
+        amount: number;
+        currency: string;
+    };
+    daily_budget_cap?: number | null;
+    budget_allocation?: unknown;
+    pacing?: unknown;
+    bidding?: unknown;
+    reporting_webhook?: unknown;
     paused?: boolean;
     canceled?: true;
     cancellation_reason?: string;
@@ -68,13 +105,24 @@ export interface UpdateMediaBuyRequestLike {
     new_packages?: ReadonlyArray<unknown>;
     packages?: ReadonlyArray<{
         package_id: string;
-        budget?: number;
+        context?: unknown;
+        ext?: unknown;
+        cancellation_reason?: string;
+        catalogs?: unknown;
+        catalog_ids?: readonly string[];
+        bid_price?: number;
+        optimization_goals?: unknown;
+        impressions?: number;
+        budget?: number | null;
+        daily_budget_cap?: number | null;
+        min_spend_target?: number | null;
+        bidding?: unknown;
         pacing?: unknown;
         start_time?: string;
         end_time?: string;
         paused?: boolean;
         canceled?: true;
-        targeting_overlay?: {
+        targeting_overlay?: NonNullable<ControlMediaBuyRequest['packages']>[number]['targeting_overlay'] | {
             frequency_cap?: unknown;
             [k: string]: unknown;
         };