@adcp/sdk 8.1.0-beta.13 → 8.1.0-beta.14

package/dist/lib/types/update-media-buy.d.ts

@@ -1216,6 +1216,11 @@ export type DisclosurePersistence = 'continuous' | 'initial' | 'flexible';
  */
 export type DisclosurePosition = 'prominent' | 'footer' | 'audio' | 'subtitle' | 'overlay' | 'end_card' | 'pre_roll' | 'companion';
 
+/**
+ * Distance unit
+ */
+export type DistanceUnit = 'km' | 'mi' | 'm';
+
 /**
  * A time duration expressed as an interval and unit. Used for frequency cap windows, attribution windows, reach optimization windows, time budgets, and other time-based settings. When unit is 'campaign', interval must be 1 — the window spans the full campaign flight.
  */
@@ -3026,9 +3031,98 @@ export interface TargetingOverlay {
     /**
      * Target users within travel time, distance, or a custom boundary around arbitrary geographic points. Multiple entries use OR semantics — a user within range of any listed point is eligible. For campaigns targeting 10+ locations, consider using store_catchments with a location catalog instead. Seller must declare support in get_adcp_capabilities.
      */
-    geo_proximity?: {
-        [k: string]: unknown | undefined;
-    }[];
+    geo_proximity?: ({
+        /**
+         * Latitude in decimal degrees (WGS 84). Required for travel_time and radius methods.
+         * @minimum -90
+         * @maximum 90
+         */
+        lat: number;
+        /**
+         * Longitude in decimal degrees (WGS 84). Required for travel_time and radius methods.
+         * @minimum -180
+         * @maximum 180
+         */
+        lng: number;
+        /**
+         * Human-readable label for this entry (e.g., 'Düsseldorf', 'Heathrow Airport', 'Primary trade area').
+         */
+        label?: string;
+        /**
+         * Travel time limit for isochrone calculation. The platform resolves this to a geographic boundary based on actual transportation networks.
+         */
+        travel_time: {
+            /**
+             * Travel time limit.
+             * @minimum 1
+             */
+            value: number;
+            unit: TravelTimeUnit;
+        };
+        transport_mode: TransportMode;
+        ext?: ExtensionObject;
+    } | {
+        /**
+         * Latitude in decimal degrees (WGS 84). Required for travel_time and radius methods.
+         * @minimum -90
+         * @maximum 90
+         */
+        lat: number;
+        /**
+         * Longitude in decimal degrees (WGS 84). Required for travel_time and radius methods.
+         * @minimum -180
+         * @maximum 180
+         */
+        lng: number;
+        /**
+         * Human-readable label for this entry (e.g., 'Düsseldorf', 'Heathrow Airport', 'Primary trade area').
+         */
+        label?: string;
+        transport_mode?: TransportMode;
+        /**
+         * Simple radius from the point. The platform draws a circle of this distance around the coordinates.
+         */
+        radius: {
+            /**
+             * Radius distance.
+             */
+            value: number;
+            unit: DistanceUnit;
+        };
+        ext?: ExtensionObject;
+    } | {
+        /**
+         * Latitude in decimal degrees (WGS 84). Required for travel_time and radius methods.
+         * @minimum -90
+         * @maximum 90
+         */
+        lat?: number;
+        /**
+         * Longitude in decimal degrees (WGS 84). Required for travel_time and radius methods.
+         * @minimum -180
+         * @maximum 180
+         */
+        lng?: number;
+        /**
+         * Human-readable label for this entry (e.g., 'Düsseldorf', 'Heathrow Airport', 'Primary trade area').
+         */
+        label?: string;
+        transport_mode?: TransportMode;
+        /**
+         * Pre-computed GeoJSON geometry defining the proximity boundary. Use when the buyer has already calculated isochrones (via TravelTime, Mapbox, etc.) or has custom boundaries. When geometry is provided, lat/lng are not required.
+         */
+        geometry: {
+            /**
+             * GeoJSON geometry type.
+             */
+            type: 'Polygon' | 'MultiPolygon';
+            /**
+             * GeoJSON coordinates array. For Polygon: array of linear rings. For MultiPolygon: array of polygons.
+             */
+            coordinates: unknown[];
+        };
+        ext?: ExtensionObject;
+    })[];
     /**
      * Restrict to users with specific language preferences. ISO 639-1 codes (e.g., 'en', 'es', 'fr').
      */
@@ -3091,6 +3185,16 @@ export interface TextAsset {
     provenance?: Provenance;
 }
 
+/**
+ * Transportation mode for isochrone calculation. Required when travel_time is provided.
+ */
+export type TransportMode = 'walking' | 'cycling' | 'driving' | 'public_transport';
+
+/**
+ * Time unit for isochrone (travel-time catchment) calculations.
+ */
+export type TravelTimeUnit = 'min' | 'hr';
+
 /**
  * URL reference asset. `url_type` declares the mechanism a receiver uses to invoke the URL (clickthrough vs. tracker_pixel vs. tracker_script) and is distinct from the URL's purpose, which the format declares in `url-asset-requirements.role` (clickthrough, landing_page, impression_tracker, click_tracker, viewability_tracker, third_party_tracker). Senders SHOULD include `url_type` on every URL asset. When `url_type` is absent, receivers SHOULD fall back to the format's `url-asset-requirements.role` per this mapping: clickthrough/landing_page → `clickthrough`; impression_tracker/click_tracker → `tracker_pixel`; viewability_tracker → `tracker_script` (OMID and equivalent verification SDKs require a <script> tag — firing them as a pixel produces no measurement); third_party_tracker → no safe fallback (mechanism is integration-specific — DV/IAS ship both pixel and script forms — receivers MAY reject or warn). When neither `url_type` nor a format-side `role` is available, receivers MUST NOT silently pick a mechanism; they SHOULD reject the manifest. Note: VAST/DAAST tag URLs are not URL assets — use `asset_type: "vast"` (or the dedicated tracker types pending RFC #2915), not `asset_type: "url"` with a tracker_pixel mechanism.
  */

package/dist/lib/types/v3-1-beta/tools.generated.d.ts

@@ -21273,6 +21273,26 @@ export interface ComplyTestControllerRequest {
          */
         upstream_name?: string;
         result?: AdCPAsyncResponseData;
+        /**
+         * ISO 8601 timestamp; only return calls recorded at or after this time. Default: session start. Used by storyboard runners to scope upstream_traffic assertions to a specific step's window.
+         */
+        since_timestamp?: string;
+        /**
+         * Optional server-side filter; reduces response size. Wildcard pattern matched against `<METHOD> <URL>`, e.g. 'POST * /audience/upload' or 'POST *'. When omitted, all recorded calls in the window are returned. **Grammar (normative):** `*` matches zero or more characters of any kind including `/`. No other characters have wildcard semantics — `?` is a literal question mark, `[` and `]` are literal brackets, etc. There is no escape mechanism — `*` is always a wildcard; if literal-asterisk matching is required, callers omit `endpoint_pattern` and filter response-side. Implementations MUST anchor the pattern (full-string match, not substring search). This narrow grammar is intentional — `endpoint_pattern` exists to discriminate platform endpoints (e.g., `POST * /audience/upload` vs `POST * /events/log`), not to express full path-segment grammars. Cross-runner determinism depends on this pinning: a runner that ships POSIX-glob semantics (`*` per-segment, `?` single-char-any) would grade the same storyboard differently than a runner picking the more permissive single-wildcard reading.
+         */
+        endpoint_pattern?: string;
+        /**
+         * Maximum number of calls to return. The response carries `total_count` and `truncated` so the runner can detect overflow.
+         */
+        limit?: number;
+        /**
+         * Requested response shape per recorded call. `raw` (default) returns full payload — the load-bearing assertion target for arbitrary `payload_must_contain` paths, and the existing v2.0.0 contract. `digest` returns only `payload_digest_sha256` + `payload_length` + `content_type` + optional `identifier_match_proofs[]`, so privacy-conscious adopters can support `upstream_traffic` conformance without raw-payload disclosure. Whether digest mode satisfies a given adopter's data-handling obligations (GDPR processor responsibilities, internal data-classification policy, contractual restrictions) is for that adopter's counsel to determine — the spec doesn't promise digest mode clears any specific legal bar. Synthetic-vectors-only still applies (see UpstreamTrafficSuccess top-level description in comply-test-controller-response.json): digest mode reduces what the runner sees, but the controller must still operate on synthetic test data, not production traffic — running queries against production payloads would let a runner with a precomputed digest set learn membership of arbitrary identifiers in the adopter's user base. Adopters MAY unilaterally downgrade a `raw` request to `digest` when their policy requires it; the response's per-call `attestation_mode` field echoes what was actually returned. Storyboards that strictly require raw introspection set `attestation_mode_required: "raw"` on their `upstream_traffic` check — calls returned in digest mode then grade not_applicable rather than failing.
+         */
+        attestation_mode?: 'raw' | 'digest';
+        /**
+         * When `attestation_mode` is `digest`, the runner MAY supply SHA-256 digests (lowercase hex, 64 chars) of identifier values it wants the controller to verify echo for. The controller scans each recorded call's payload for string tokens whose SHA-256 hash matches any digest in this list and returns booleans in `recorded_calls[].identifier_match_proofs[]`. Lets the runner verify `identifier_paths` echo without ever transmitting plaintext identifiers to the controller — the digest is the comparison key. Cap of 64 digests per query to bound the controller's work; storyboards with more identifiers SHOULD batch across multiple queries. Has no effect when `attestation_mode` is `raw` (the runner does the matching in-process against the full payload).
+         */
+        identifier_value_digests?: string[];
     };
     context?: ContextObject;
     ext?: ExtensionObject;