@adcp/sdk 17.0.0-beta.0 → 17.0.0-beta.2

package/dist/lib/validation/compact-schema.js

@@ -0,0 +1,276 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compact_schema_exports = {};
+__export(compact_schema_exports, {
+  COMPACT_DEFINITIONS_KEY: () => COMPACT_DEFINITIONS_KEY,
+  compactBundledSchema: () => compactBundledSchema,
+  compactSchemaForValidation: () => compactSchemaForValidation
+});
+module.exports = __toCommonJS(compact_schema_exports);
+var import_node_crypto = require("node:crypto");
+const COMPACT_DEFINITIONS_KEY = "x-adcp-compact-definitions";
+const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
+const SCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const SCHEMA_VALUE_KEYWORDS = /* @__PURE__ */ new Set([
+  "additionalProperties",
+  "additionalItems",
+  "contains",
+  "if",
+  "then",
+  "else",
+  "not",
+  "propertyNames",
+  "contentSchema",
+  "unevaluatedProperties",
+  "unevaluatedItems"
+]);
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function forEachChildSchema(schema, visit) {
+  for (const [keyword, value] of Object.entries(schema)) {
+    if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+      for (const child of Object.values(value)) visit(child);
+    } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+      for (const child of value) visit(child);
+    } else if (SCHEMA_VALUE_KEYWORDS.has(keyword)) {
+      visit(value);
+    } else if (keyword === "items") {
+      if (Array.isArray(value)) {
+        for (const child of value) visit(child);
+      } else {
+        visit(value);
+      }
+    } else if (keyword === "dependencies" && isObject(value)) {
+      for (const child of Object.values(value)) {
+        if (!Array.isArray(child)) visit(child);
+      }
+    }
+  }
+}
+function cloneData(value) {
+  if (Array.isArray(value)) return value.map(cloneData);
+  if (!isObject(value)) return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneData(child)]));
+}
+function compactBundledSchema(root, options = {}) {
+  const referenceCounts = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const countSchema = (value) => {
+    if (!isObject(value)) return;
+    referenceCounts.set(value, (referenceCounts.get(value) ?? 0) + 1);
+    if (visited.has(value)) return;
+    visited.add(value);
+    forEachChildSchema(value, countSchema);
+  };
+  countSchema(root);
+  const pointerAddressedNodes = /* @__PURE__ */ new Set();
+  const unionAlternatives = /* @__PURE__ */ new Set();
+  if (options.maxInlineSchemaBytes !== void 0) {
+    const rootUrl = new URL(typeof root.$id === "string" ? root.$id : "", "https://adcp.invalid/");
+    rootUrl.hash = "";
+    for (const schema of visited) {
+      for (const keyword of ["oneOf", "anyOf"]) {
+        const alternatives = schema[keyword];
+        if (Array.isArray(alternatives)) {
+          for (const alternative of alternatives) if (isObject(alternative)) unionAlternatives.add(alternative);
+        }
+      }
+      if (typeof schema.$ref !== "string") continue;
+      let fragment;
+      try {
+        const target = new URL(schema.$ref, rootUrl);
+        fragment = decodeURIComponent(target.hash.slice(1));
+        target.hash = "";
+        if (target.href !== rootUrl.href || !fragment.startsWith("/")) continue;
+      } catch {
+        continue;
+      }
+      let value = root;
+      for (const segment of fragment.slice(1).split("/")) {
+        if (isObject(value)) pointerAddressedNodes.add(value);
+        if (!isObject(value) && !Array.isArray(value)) break;
+        const key = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+        value = value[key];
+      }
+      if (isObject(value)) pointerAddressedNodes.add(value);
+    }
+  }
+  const signatureCache = /* @__PURE__ */ new Map();
+  const weightCache = /* @__PURE__ */ new Map();
+  const schemaSignature = (schema) => {
+    const cached = signatureCache.get(schema);
+    if (cached) return cached;
+    const hash = (0, import_node_crypto.createHash)("sha256");
+    const updateHash = (value) => {
+      hash.update(`${Buffer.byteLength(value)}:`);
+      hash.update(value);
+    };
+    let weight = 2;
+    for (const [keyword, value] of Object.entries(schema)) {
+      updateHash(keyword);
+      if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+          updateHash(key);
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        for (const child of value) {
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (SCHEMA_VALUE_KEYWORDS.has(keyword) && isObject(value)) {
+        updateHash(schemaSignature(value));
+        weight += weightCache.get(value) ?? 0;
+      } else if (keyword === "items") {
+        updateHash(Array.isArray(value) ? "tuple" : "single");
+        const children = Array.isArray(value) ? value : [value];
+        for (const child of children) {
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (keyword === "dependencies" && isObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+          updateHash(key);
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else {
+        const serialized = JSON.stringify(value);
+        updateHash(serialized);
+        weight += Buffer.byteLength(serialized);
+      }
+    }
+    const signature = hash.digest("hex");
+    signatureCache.set(schema, signature);
+    weightCache.set(schema, weight);
+    return signature;
+  };
+  const signatureGroups = /* @__PURE__ */ new Map();
+  for (const schema of visited) {
+    if (schema === root || pointerAddressedNodes.has(schema) || unionAlternatives.has(schema)) continue;
+    const signature = schemaSignature(schema);
+    const group = signatureGroups.get(signature) ?? [];
+    group.push(schema);
+    signatureGroups.set(signature, group);
+  }
+  const sharedNames = /* @__PURE__ */ new Map();
+  const sharedDefinitions = /* @__PURE__ */ new Map();
+  const reservedNames = new Set(isObject(root.$defs) ? Object.keys(root.$defs) : []);
+  let sharedIndex = 0;
+  for (const group of signatureGroups.values()) {
+    const useCount = group.reduce((sum, schema) => sum + (referenceCounts.get(schema) ?? 0), 0);
+    const weight = weightCache.get(group[0]) ?? 0;
+    const identityShared = group.some((schema) => (referenceCounts.get(schema) ?? 0) > 1);
+    const largeValidationNode = options.maxInlineSchemaBytes !== void 0 && weight >= options.maxInlineSchemaBytes;
+    if (!largeValidationNode && (useCount < 2 || !identityShared && weight < 256)) continue;
+    let name;
+    do
+      name = `__adcp_shared_${sharedIndex++}`;
+    while (reservedNames.has(name));
+    reservedNames.add(name);
+    for (const schema of group) sharedNames.set(schema, name);
+    sharedDefinitions.set(name, group[0]);
+  }
+  const encodeSchema = (schema, expanding, ancestors = /* @__PURE__ */ new Set()) => {
+    if (!isObject(schema)) return schema;
+    const sharedName = sharedNames.get(schema);
+    if (sharedName && schema !== expanding) return { $ref: `#/$defs/${sharedName}` };
+    if (ancestors.has(schema)) {
+      if (!sharedName) throw new Error("Dereferenced schema contains an unaddressable cycle");
+      return { $ref: `#/$defs/${sharedName}` };
+    }
+    const nextAncestors = new Set(ancestors);
+    nextAncestors.add(schema);
+    const encoded = {};
+    for (const [keyword, value] of Object.entries(schema)) {
+      if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+        encoded[keyword] = Object.fromEntries(
+          Object.entries(value).map(([key, child]) => [key, encodeSchema(child, void 0, nextAncestors)])
+        );
+      } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        encoded[keyword] = value.map((child) => encodeSchema(child, void 0, nextAncestors));
+      } else if (SCHEMA_VALUE_KEYWORDS.has(keyword)) {
+        encoded[keyword] = encodeSchema(value, void 0, nextAncestors);
+      } else if (keyword === "items") {
+        encoded[keyword] = Array.isArray(value) ? value.map((child) => encodeSchema(child, void 0, nextAncestors)) : encodeSchema(value, void 0, nextAncestors);
+      } else if (keyword === "dependencies" && isObject(value)) {
+        encoded[keyword] = Object.fromEntries(
+          Object.entries(value).map(([key, child]) => [
+            key,
+            Array.isArray(child) ? cloneData(child) : encodeSchema(child, void 0, nextAncestors)
+          ])
+        );
+      } else {
+        encoded[keyword] = cloneData(value);
+      }
+    }
+    return encoded;
+  };
+  const compacted = encodeSchema(root, root);
+  if (compacted[COMPACT_DEFINITIONS_KEY] !== void 0) {
+    throw new Error(`Schema already contains reserved property ${COMPACT_DEFINITIONS_KEY}`);
+  }
+  const defs = isObject(compacted.$defs) ? { ...compacted.$defs } : {};
+  for (const [name, schema] of sharedDefinitions) defs[name] = encodeSchema(schema, schema);
+  if (Object.keys(defs).length > 0) compacted.$defs = defs;
+  if (sharedDefinitions.size > 0) compacted[COMPACT_DEFINITIONS_KEY] = [...sharedDefinitions.keys()];
+  return compacted;
+}
+function compactSchemaForValidation(schema) {
+  const copied = cloneData(schema);
+  const stripIds = (node, root = false) => {
+    if (!isObject(node)) return;
+    if (!root) delete node.$id;
+    forEachChildSchema(node, (child) => stripIds(child));
+  };
+  stripIds(copied, true);
+  return compactBundledSchema(copied, { maxInlineSchemaBytes: 1024 });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMPACT_DEFINITIONS_KEY,
+  compactBundledSchema,
+  compactSchemaForValidation
+});

package/dist/lib/validation/compact-schema.mjs

@@ -0,0 +1,250 @@
+import { createHash } from "node:crypto";
+const COMPACT_DEFINITIONS_KEY = "x-adcp-compact-definitions";
+const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
+const SCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const SCHEMA_VALUE_KEYWORDS = /* @__PURE__ */ new Set([
+  "additionalProperties",
+  "additionalItems",
+  "contains",
+  "if",
+  "then",
+  "else",
+  "not",
+  "propertyNames",
+  "contentSchema",
+  "unevaluatedProperties",
+  "unevaluatedItems"
+]);
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function forEachChildSchema(schema, visit) {
+  for (const [keyword, value] of Object.entries(schema)) {
+    if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+      for (const child of Object.values(value)) visit(child);
+    } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+      for (const child of value) visit(child);
+    } else if (SCHEMA_VALUE_KEYWORDS.has(keyword)) {
+      visit(value);
+    } else if (keyword === "items") {
+      if (Array.isArray(value)) {
+        for (const child of value) visit(child);
+      } else {
+        visit(value);
+      }
+    } else if (keyword === "dependencies" && isObject(value)) {
+      for (const child of Object.values(value)) {
+        if (!Array.isArray(child)) visit(child);
+      }
+    }
+  }
+}
+function cloneData(value) {
+  if (Array.isArray(value)) return value.map(cloneData);
+  if (!isObject(value)) return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneData(child)]));
+}
+function compactBundledSchema(root, options = {}) {
+  const referenceCounts = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const countSchema = (value) => {
+    if (!isObject(value)) return;
+    referenceCounts.set(value, (referenceCounts.get(value) ?? 0) + 1);
+    if (visited.has(value)) return;
+    visited.add(value);
+    forEachChildSchema(value, countSchema);
+  };
+  countSchema(root);
+  const pointerAddressedNodes = /* @__PURE__ */ new Set();
+  const unionAlternatives = /* @__PURE__ */ new Set();
+  if (options.maxInlineSchemaBytes !== void 0) {
+    const rootUrl = new URL(typeof root.$id === "string" ? root.$id : "", "https://adcp.invalid/");
+    rootUrl.hash = "";
+    for (const schema of visited) {
+      for (const keyword of ["oneOf", "anyOf"]) {
+        const alternatives = schema[keyword];
+        if (Array.isArray(alternatives)) {
+          for (const alternative of alternatives) if (isObject(alternative)) unionAlternatives.add(alternative);
+        }
+      }
+      if (typeof schema.$ref !== "string") continue;
+      let fragment;
+      try {
+        const target = new URL(schema.$ref, rootUrl);
+        fragment = decodeURIComponent(target.hash.slice(1));
+        target.hash = "";
+        if (target.href !== rootUrl.href || !fragment.startsWith("/")) continue;
+      } catch {
+        continue;
+      }
+      let value = root;
+      for (const segment of fragment.slice(1).split("/")) {
+        if (isObject(value)) pointerAddressedNodes.add(value);
+        if (!isObject(value) && !Array.isArray(value)) break;
+        const key = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+        value = value[key];
+      }
+      if (isObject(value)) pointerAddressedNodes.add(value);
+    }
+  }
+  const signatureCache = /* @__PURE__ */ new Map();
+  const weightCache = /* @__PURE__ */ new Map();
+  const schemaSignature = (schema) => {
+    const cached = signatureCache.get(schema);
+    if (cached) return cached;
+    const hash = createHash("sha256");
+    const updateHash = (value) => {
+      hash.update(`${Buffer.byteLength(value)}:`);
+      hash.update(value);
+    };
+    let weight = 2;
+    for (const [keyword, value] of Object.entries(schema)) {
+      updateHash(keyword);
+      if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+          updateHash(key);
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        for (const child of value) {
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (SCHEMA_VALUE_KEYWORDS.has(keyword) && isObject(value)) {
+        updateHash(schemaSignature(value));
+        weight += weightCache.get(value) ?? 0;
+      } else if (keyword === "items") {
+        updateHash(Array.isArray(value) ? "tuple" : "single");
+        const children = Array.isArray(value) ? value : [value];
+        for (const child of children) {
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (keyword === "dependencies" && isObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+          updateHash(key);
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else {
+        const serialized = JSON.stringify(value);
+        updateHash(serialized);
+        weight += Buffer.byteLength(serialized);
+      }
+    }
+    const signature = hash.digest("hex");
+    signatureCache.set(schema, signature);
+    weightCache.set(schema, weight);
+    return signature;
+  };
+  const signatureGroups = /* @__PURE__ */ new Map();
+  for (const schema of visited) {
+    if (schema === root || pointerAddressedNodes.has(schema) || unionAlternatives.has(schema)) continue;
+    const signature = schemaSignature(schema);
+    const group = signatureGroups.get(signature) ?? [];
+    group.push(schema);
+    signatureGroups.set(signature, group);
+  }
+  const sharedNames = /* @__PURE__ */ new Map();
+  const sharedDefinitions = /* @__PURE__ */ new Map();
+  const reservedNames = new Set(isObject(root.$defs) ? Object.keys(root.$defs) : []);
+  let sharedIndex = 0;
+  for (const group of signatureGroups.values()) {
+    const useCount = group.reduce((sum, schema) => sum + (referenceCounts.get(schema) ?? 0), 0);
+    const weight = weightCache.get(group[0]) ?? 0;
+    const identityShared = group.some((schema) => (referenceCounts.get(schema) ?? 0) > 1);
+    const largeValidationNode = options.maxInlineSchemaBytes !== void 0 && weight >= options.maxInlineSchemaBytes;
+    if (!largeValidationNode && (useCount < 2 || !identityShared && weight < 256)) continue;
+    let name;
+    do
+      name = `__adcp_shared_${sharedIndex++}`;
+    while (reservedNames.has(name));
+    reservedNames.add(name);
+    for (const schema of group) sharedNames.set(schema, name);
+    sharedDefinitions.set(name, group[0]);
+  }
+  const encodeSchema = (schema, expanding, ancestors = /* @__PURE__ */ new Set()) => {
+    if (!isObject(schema)) return schema;
+    const sharedName = sharedNames.get(schema);
+    if (sharedName && schema !== expanding) return { $ref: `#/$defs/${sharedName}` };
+    if (ancestors.has(schema)) {
+      if (!sharedName) throw new Error("Dereferenced schema contains an unaddressable cycle");
+      return { $ref: `#/$defs/${sharedName}` };
+    }
+    const nextAncestors = new Set(ancestors);
+    nextAncestors.add(schema);
+    const encoded = {};
+    for (const [keyword, value] of Object.entries(schema)) {
+      if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+        encoded[keyword] = Object.fromEntries(
+          Object.entries(value).map(([key, child]) => [key, encodeSchema(child, void 0, nextAncestors)])
+        );
+      } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        encoded[keyword] = value.map((child) => encodeSchema(child, void 0, nextAncestors));
+      } else if (SCHEMA_VALUE_KEYWORDS.has(keyword)) {
+        encoded[keyword] = encodeSchema(value, void 0, nextAncestors);
+      } else if (keyword === "items") {
+        encoded[keyword] = Array.isArray(value) ? value.map((child) => encodeSchema(child, void 0, nextAncestors)) : encodeSchema(value, void 0, nextAncestors);
+      } else if (keyword === "dependencies" && isObject(value)) {
+        encoded[keyword] = Object.fromEntries(
+          Object.entries(value).map(([key, child]) => [
+            key,
+            Array.isArray(child) ? cloneData(child) : encodeSchema(child, void 0, nextAncestors)
+          ])
+        );
+      } else {
+        encoded[keyword] = cloneData(value);
+      }
+    }
+    return encoded;
+  };
+  const compacted = encodeSchema(root, root);
+  if (compacted[COMPACT_DEFINITIONS_KEY] !== void 0) {
+    throw new Error(`Schema already contains reserved property ${COMPACT_DEFINITIONS_KEY}`);
+  }
+  const defs = isObject(compacted.$defs) ? { ...compacted.$defs } : {};
+  for (const [name, schema] of sharedDefinitions) defs[name] = encodeSchema(schema, schema);
+  if (Object.keys(defs).length > 0) compacted.$defs = defs;
+  if (sharedDefinitions.size > 0) compacted[COMPACT_DEFINITIONS_KEY] = [...sharedDefinitions.keys()];
+  return compacted;
+}
+function compactSchemaForValidation(schema) {
+  const copied = cloneData(schema);
+  const stripIds = (node, root = false) => {
+    if (!isObject(node)) return;
+    if (!root) delete node.$id;
+    forEachChildSchema(node, (child) => stripIds(child));
+  };
+  stripIds(copied, true);
+  return compactBundledSchema(copied, { maxInlineSchemaBytes: 1024 });
+}
+export {
+  COMPACT_DEFINITIONS_KEY,
+  compactBundledSchema,
+  compactSchemaForValidation
+};

package/dist/lib/validation/media-buy-delivery-report.d.mts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { MediaBuyDeliveryReport } from '../types/media-buy-delivery-report.mjs';
+/**
+ * Payload-only reporting shape at the SDK pin. Poll responses still require
+ * their task status; webhook receivers validate the separate outer envelope.
+ * Use parseMediaBuyDeliveryWebhook for strict validation at an older release.
+ */
+export declare const MediaBuyDeliveryReportSchema: z.ZodType<MediaBuyDeliveryReport>;

package/dist/lib/validation/media-buy-delivery-report.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { MediaBuyDeliveryReport } from '../types/media-buy-delivery-report';
+/**
+ * Payload-only reporting shape at the SDK pin. Poll responses still require
+ * their task status; webhook receivers validate the separate outer envelope.
+ * Use parseMediaBuyDeliveryWebhook for strict validation at an older release.
+ */
+export declare const MediaBuyDeliveryReportSchema: z.ZodType<MediaBuyDeliveryReport>;

package/dist/lib/validation/media-buy-delivery-report.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var media_buy_delivery_report_exports = {};
+__export(media_buy_delivery_report_exports, {
+  MediaBuyDeliveryReportSchema: () => MediaBuyDeliveryReportSchema
+});
+module.exports = __toCommonJS(media_buy_delivery_report_exports);
+var import_schemas = require('../types/schemas.generated.js');
+const MediaBuyDeliveryReportSchema = /* @__PURE__ */ import_schemas.GetMediaBuyDeliveryResponseSchema.omit({
+  status: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MediaBuyDeliveryReportSchema
+});

package/dist/lib/validation/media-buy-delivery-report.mjs

@@ -0,0 +1,7 @@
+import { GetMediaBuyDeliveryResponseSchema } from "../types/schemas.generated.mjs";
+const MediaBuyDeliveryReportSchema = /* @__PURE__ */ GetMediaBuyDeliveryResponseSchema.omit({
+  status: true
+});
+export {
+  MediaBuyDeliveryReportSchema
+};

package/dist/lib/validation/nonempty-array.d.mts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+type ArrayBoundMethods = 'min' | 'max' | 'length' | 'nonempty';
+/** A normal ZodArray whose checked minimum is reflected in its input/output. */
+export interface NonemptyArraySchema<Element extends z.ZodType> extends Omit<z.ZodArray<Element>, keyof z.ZodType | ArrayBoundMethods>, z.ZodType<[z.output<Element>, ...z.output<Element>[]], [z.input<Element>, ...z.input<Element>[]]> {
+    min(...args: Parameters<z.ZodArray<Element>['min']>): this;
+    max(...args: Parameters<z.ZodArray<Element>['max']>): this;
+    length(...args: Parameters<z.ZodArray<Element>['length']>): this;
+    nonempty(...args: Parameters<z.ZodArray<Element>['nonempty']>): this;
+}
+/**
+ * Zod 4's .min(1) retains an array type. Reflect the enforced bound without
+ * turning homogeneous wire arrays into JSON Schema prefixItems tuples.
+ */
+export declare function nonemptyArray<Element extends z.ZodType>(element: Element): NonemptyArraySchema<Element>;
+export {};

package/dist/lib/validation/nonempty-array.d.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+type ArrayBoundMethods = 'min' | 'max' | 'length' | 'nonempty';
+/** A normal ZodArray whose checked minimum is reflected in its input/output. */
+export interface NonemptyArraySchema<Element extends z.ZodType> extends Omit<z.ZodArray<Element>, keyof z.ZodType | ArrayBoundMethods>, z.ZodType<[z.output<Element>, ...z.output<Element>[]], [z.input<Element>, ...z.input<Element>[]]> {
+    min(...args: Parameters<z.ZodArray<Element>['min']>): this;
+    max(...args: Parameters<z.ZodArray<Element>['max']>): this;
+    length(...args: Parameters<z.ZodArray<Element>['length']>): this;
+    nonempty(...args: Parameters<z.ZodArray<Element>['nonempty']>): this;
+}
+/**
+ * Zod 4's .min(1) retains an array type. Reflect the enforced bound without
+ * turning homogeneous wire arrays into JSON Schema prefixItems tuples.
+ */
+export declare function nonemptyArray<Element extends z.ZodType>(element: Element): NonemptyArraySchema<Element>;
+export {};

package/dist/lib/validation/nonempty-array.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nonempty_array_exports = {};
+__export(nonempty_array_exports, {
+  nonemptyArray: () => nonemptyArray
+});
+module.exports = __toCommonJS(nonempty_array_exports);
+var z = __toESM(require("zod"));
+function nonemptyArray(element) {
+  return z.array(element).min(1);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  nonemptyArray
+});

package/dist/lib/validation/nonempty-array.mjs

@@ -0,0 +1,7 @@
+import * as z from "zod";
+function nonemptyArray(element) {
+  return z.array(element).min(1);
+}
+export {
+  nonemptyArray
+};