@mediaviz/sdk 1.7.0 → 1.8.0-dev.100

package/dist/sdk.umd.js

@@ -465,6 +465,448 @@
 		return types;
 	}
 
+	var src$1;
+	var hasRequiredSrc$1;
+
+	function requireSrc$1 () {
+		if (hasRequiredSrc$1) return src$1;
+		hasRequiredSrc$1 = 1;
+
+		const { OAuthClient } = requireClient();
+		const { OAuthError } = requireErrors();
+		const { OAuthErrorCode } = requireTypes();
+
+		src$1 = { OAuthClient, OAuthError, OAuthErrorCode };
+		return src$1;
+	}
+
+	var srcExports$1 = requireSrc$1();
+	var _oauth = /*@__PURE__*/getDefaultExportFromCjs(srcExports$1);
+
+	// Auto-generated — do not edit
+	const { OAuthClient, OAuthError, OAuthErrorCode } = _oauth;
+
+	var signing;
+	var hasRequiredSigning;
+
+	function requireSigning () {
+		if (hasRequiredSigning) return signing;
+		hasRequiredSigning = 1;
+
+		// HMAC scheme shared with the MediaViz producer: X-Signature = 'sha256=' +
+		// hex(HMAC-SHA256(secret, `${X-Timestamp}.` + rawBody)). The signing string is
+		// the timestamp joined to the *raw request body bytes* — never re-serialized
+		// JSON. Verification accepts the current and (during rotation) previous
+		// secret, rejects timestamps outside the skew window, and compares digests in
+		// constant time. Web Crypto only, so the same code runs in Node >= 18 and
+		// browsers.
+
+		const _encoder = new TextEncoder();
+
+		async function signWebhookPayload(secret, timestamp, rawBody) {
+		  const key = await globalThis.crypto.subtle.importKey(
+		    'raw', _encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+		  const payload = _concat(_encoder.encode(`${timestamp}.`), toBytes(rawBody));
+		  const digest = await globalThis.crypto.subtle.sign('HMAC', key, payload);
+		  return 'sha256=' + _hex(new Uint8Array(digest));
+		}
+
+		async function verifyWebhookSignature(secretCurrent, secretPrevious, headers, rawBody, options = {}) {
+		  const h = lowerHeaders(headers);
+		  const timestamp = h['x-timestamp'];
+		  const signature = h['x-signature'];
+		  if (!timestamp || !signature) return false;
+		  if (!/^-?\d+$/.test(String(timestamp))) return false;
+		  const skewToleranceS = options.skewToleranceS ?? 300;
+		  const now = options.now ?? Math.floor(Date.now() / 1000);
+		  if (Math.abs(now - Number(timestamp)) > skewToleranceS) return false;
+		  for (const secret of [secretCurrent, secretPrevious]) {
+		    if (!secret) continue;
+		    const expected = await signWebhookPayload(secret, String(timestamp), rawBody);
+		    if (_constantTimeEqual(expected, String(signature))) return true;
+		  }
+		  return false;
+		}
+
+		// helpers
+		function toBytes(rawBody) {
+		  if (typeof rawBody === 'string') return _encoder.encode(rawBody);
+		  if (rawBody instanceof Uint8Array) return rawBody;
+		  if (rawBody instanceof ArrayBuffer) return new Uint8Array(rawBody);
+		  throw new TypeError('rawBody must be a string, Uint8Array, or ArrayBuffer');
+		}
+
+		function lowerHeaders(headers) {
+		  const out = {};
+		  const entries = typeof headers?.entries === 'function' ? headers.entries() : Object.entries(headers ?? {});
+		  for (const [k, v] of entries) out[String(k).toLowerCase()] = v;
+		  return out;
+		}
+
+		function _concat(a, b) {
+		  const out = new Uint8Array(a.length + b.length);
+		  out.set(a, 0);
+		  out.set(b, a.length);
+		  return out;
+		}
+
+		function _hex(bytes) {
+		  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+		}
+
+		function _constantTimeEqual(a, b) {
+		  if (a.length !== b.length) return false;
+		  let diff = 0;
+		  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+		  return diff === 0;
+		}
+
+		signing = { signWebhookPayload, verifyWebhookSignature, toBytes, lowerHeaders };
+		return signing;
+	}
+
+	var store;
+	var hasRequiredStore;
+
+	function requireStore () {
+		if (hasRequiredStore) return store;
+		hasRequiredStore = 1;
+
+		// Persistence seam for the webhook consumer: dedupe ledger, signing secrets,
+		// and pull cursors. The default in-memory store suits a single long-lived
+		// process (worker, dev server); multi-process consumers supply an object with
+		// the same shape backed by Redis or a database.
+
+		const MAX_SEEN_ENTRIES = 100000;
+
+		class InMemoryWebhookStore {
+		  constructor() {
+		    this._seen = new Map();     // eventId -> expiresAt (ms)
+		    this._secrets = new Map();  // subscriptionId -> {current, previous, previousExpiresAt}
+		    this._cursors = new Map();  // subscriptionId -> cursor
+		  }
+
+		  markSeen(eventId, ttlS) {
+		    const now = Date.now();
+		    const expiresAt = this._seen.get(eventId);
+		    if (expiresAt !== undefined && expiresAt > now) return false;
+		    this._seen.delete(eventId);
+		    this._seen.set(eventId, now + ttlS * 1000);
+		    this._prune(now);
+		    return true;
+		  }
+
+		  unmarkSeen(eventId) {
+		    this._seen.delete(eventId);
+		  }
+
+		  saveSecret(subscriptionId, secret) {
+		    this._secrets.set(subscriptionId, { current: secret, previous: null, previousExpiresAt: 0 });
+		  }
+
+		  rotateSecret(subscriptionId, newSecret, windowS) {
+		    const entry = this._secrets.get(subscriptionId);
+		    this._secrets.set(subscriptionId, {
+		      current: newSecret,
+		      previous: entry?.current ?? null,
+		      previousExpiresAt: Date.now() + windowS * 1000,
+		    });
+		  }
+
+		  getSecrets(subscriptionId) {
+		    const entry = this._secrets.get(subscriptionId);
+		    if (!entry) return [null, null];
+		    const previous = entry.previous && entry.previousExpiresAt > Date.now() ? entry.previous : null;
+		    return [entry.current, previous];
+		  }
+
+		  getCursor(subscriptionId) {
+		    return this._cursors.get(subscriptionId) ?? null;
+		  }
+
+		  setCursor(subscriptionId, cursor) {
+		    this._cursors.set(subscriptionId, cursor);
+		  }
+
+		  _prune(now) {
+		    if (this._seen.size <= MAX_SEEN_ENTRIES) return;
+		    for (const [id, expiresAt] of this._seen) {
+		      if (expiresAt <= now) this._seen.delete(id);
+		      if (this._seen.size <= MAX_SEEN_ENTRIES) return;
+		    }
+		    // still over the cap: evict oldest insertions
+		    for (const id of this._seen.keys()) {
+		      this._seen.delete(id);
+		      if (this._seen.size <= MAX_SEEN_ENTRIES) return;
+		    }
+		  }
+		}
+
+		store = { InMemoryWebhookStore };
+		return store;
+	}
+
+	var consumer;
+	var hasRequiredConsumer;
+
+	function requireConsumer () {
+		if (hasRequiredConsumer) return consumer;
+		hasRequiredConsumer = 1;
+
+		const { verifyWebhookSignature, toBytes, lowerHeaders } = requireSigning();
+		const { InMemoryWebhookStore } = requireStore();
+
+		// Photo columns each producer model writes — used to select a model's results
+		// out of a fetched PhotoDisplay. Mirrors the producer vocabulary; personhood is
+		// predicate-based and writes no columns.
+		const WEBHOOK_MODEL_COLUMNS = {
+		  blur: ['blur_value'],
+		  colors: ['main_color_palette', 'color_averages', 'hue_values', 'light_values', 'saturation_values'],
+		  face_recognition: ['number_of_faces', 'bounding_boxes_from_faces_model'],
+		  image_classification: ['labels_from_classifications_model', 'feature_extraction_output'],
+		  image_comparison: ['average_hash'],
+		  image_describe: ['topic'],
+		  ocr: ['ocr_output'],
+		  similarity: ['similar_photo_ids_high', 'similar_photo_ids_medium', 'similar_photo_ids_low'],
+		  evidence: ['evidence_score', 'aesthetic_score', 'face_score', 'content_score', 'similarity_set_ranking'],
+		  personhood: [],
+		};
+
+		const WEBHOOK_OUTCOME_MODELS = {
+		  curation: ['blur', 'colors', 'face_recognition', 'image_classification', 'image_comparison', 'similarity', 'evidence'],
+		  similarity: ['image_classification', 'image_comparison', 'similarity'],
+		  persons: ['face_recognition', 'personhood'],
+		};
+
+		// Client-side counterpart of the MediaViz webhook producer, giving photo-by-photo
+		// progress as a project upload is analyzed.
+		//
+		// Receiver half (no auth needed): classify inbound POSTs, echo the subscription
+		// verification challenge, verify signed `target.completed` deliveries (HMAC +
+		// timestamp skew), dedupe on event_id, and dispatch each new event to a single
+		// onEvent callback. `handleRequest` is framework-agnostic glue — adapt it to
+		// express/lambda/etc. in a few lines by feeding it the raw body and headers.
+		//
+		// API half (requires an authenticated client): subscription lifecycle
+		// orchestration — register/confirm/rotate store the signing secret the moment
+		// the producer issues it — plus history pulls that share the push dedupe
+		// ledger, and out-of-band result fetches (webhooks carry a pointer, never the
+		// result itself).
+		class WebhookConsumer {
+		  constructor(ctx, subscriptionApi, options = {}) {
+		    this._ctx = ctx;
+		    this._api = subscriptionApi;
+		    this.store = options.store ?? new InMemoryWebhookStore();
+		    this.skewToleranceS = options.skewToleranceS ?? 300;
+		    this.rotationWindowS = options.rotationWindowS ?? 86400;
+		    this.dedupeTtlS = options.dedupeTtlS ?? 604800;
+		    this.pageLimit = options.pageLimit ?? 100;
+		    this._onEvent = options.onEvent ?? null;
+		  }
+
+		  // ── receiver half ─────────────────────────────────────────────────────────
+
+		  onEvent(fn) {
+		    this._onEvent = fn;
+		    return fn;
+		  }
+
+		  useStore(store) {
+		    this.store = store;
+		  }
+
+		  classifyMessage(body) {
+		    const type = body?.event_type;
+		    if (type === 'subscription.verification') return 'verification';
+		    if (type === 'target.completed') return 'delivery';
+		    return 'unknown';
+		  }
+
+		  handleChallenge(body) {
+		    return { challenge: body.challenge };
+		  }
+
+		  async handleDelivery(headers, rawBody) {
+		    let event;
+		    try {
+		      event = this._parseDelivery(rawBody);
+		    } catch {
+		      return 'bad_signature';
+		    }
+		    const [current, previous] = this.store.getSecrets(String(event.subscription_id));
+		    const ok = await verifyWebhookSignature(current, previous, headers, rawBody, { skewToleranceS: this.skewToleranceS });
+		    if (!ok) return 'bad_signature';
+		    return this._dispatch(event);
+		  }
+
+		  async handleRequest(headers, rawBody) {
+		    let body;
+		    try {
+		      body = JSON.parse(_text(rawBody));
+		    } catch {
+		      return { status: 400, body: { detail: 'invalid JSON' } };
+		    }
+		    switch (this.classifyMessage(body)) {
+		      case 'verification':
+		        return { status: 200, body: this.handleChallenge(body) };
+		      case 'delivery': {
+		        const ack = await this.handleDelivery(lowerHeaders(headers), rawBody);
+		        if (ack === 'bad_signature') return { status: 401, body: { detail: 'bad signature' } };
+		        return { status: 200, body: { status: ack } };
+		      }
+		      default:
+		        return { status: 400, body: { detail: 'unrecognized event_type' } };
+		    }
+		  }
+
+		  // ── API half ──────────────────────────────────────────────────────────────
+
+		  async register(projectTableName, callbackUrl, targets) {
+		    const res = await this._api.createSubscription(projectTableName, callbackUrl, targets);
+		    this._saveSecretFrom(res);
+		    return res;
+		  }
+
+		  async confirm(subscriptionId) {
+		    const res = await this._api.verifySubscription(subscriptionId);
+		    this._saveSecretFrom(res);
+		    return res;
+		  }
+
+		  async rotateSecret(subscriptionId) {
+		    const res = await this._api.rotateSubscriptionSecret(subscriptionId);
+		    this.store.rotateSecret(String(subscriptionId), res.signing_secret, this.rotationWindowS);
+		    return res.signing_secret;
+		  }
+
+		  async updateCallback(subscriptionId, callbackUrl) {
+		    // A callback change resets the subscription to pending_verification and
+		    // pauses push until the new URL passes the challenge — confirm right away.
+		    await this._api.updateSubscription(subscriptionId, { callbackUrl });
+		    return this.confirm(subscriptionId);
+		  }
+
+		  async disable(subscriptionId) {
+		    return this._api.deleteSubscription(subscriptionId);
+		  }
+
+		  async listSubscriptions() {
+		    return this._api.listSubscriptions();
+		  }
+
+		  async pullEvents(subscriptionId, { since, limit } = {}) {
+		    return this._api.listSubscriptionEvents(subscriptionId, { since, limit: limit ?? this.pageLimit });
+		  }
+
+		  async reconcile(subscriptionId, projectTableName) {
+		    const id = String(subscriptionId);
+		    let cursor = this.store.getCursor(id);
+		    let pulled = 0;
+		    let dispatched = 0;
+		    for (;;) {
+		      const page = await this._api.listSubscriptionEvents(id, { since: cursor ?? undefined, limit: this.pageLimit });
+		      const events = page?.events ?? [];
+		      pulled += events.length;
+		      for (const ev of events) {
+		        const ack = await this._dispatch({
+		          event_id: ev.event_id,
+		          event_type: 'target.completed',
+		          schema_version: '1',
+		          subscription_id: id,
+		          project_table_name: projectTableName,
+		          photo_id: ev.photo_id,
+		          target: ev.target,
+		          completed_at: ev.completed_at,
+		          result_location: this._ctx.baseUrl + _photoPath(projectTableName, ev.photo_id),
+		        });
+		        if (ack === 'handled') dispatched += 1;
+		      }
+		      if (page?.next_cursor && page.next_cursor !== cursor) {
+		        cursor = page.next_cursor;
+		        this.store.setCursor(id, cursor);
+		      }
+		      if (!events.length || events.length < this.pageLimit) break;
+		    }
+		    return { pulled, dispatched };
+		  }
+
+		  async fetchResult(event) {
+		    this._ctx.requireTokens();
+		    const path = _photoPath(event.project_table_name, event.photo_id);
+		    const { data } = await this._ctx.client.request(path, 'GET', this._ctx.accessToken, this._ctx.refreshToken);
+		    return { photo: data, selected: selectResultColumns(data, event.target) };
+		  }
+
+		  saveSecret(subscriptionId, secret) {
+		    this.store.saveSecret(String(subscriptionId), secret);
+		  }
+
+		  // ── internal ──────────────────────────────────────────────────────────────
+
+		  _saveSecretFrom(res) {
+		    if (res?.signing_secret && res?.subscription_id != null) {
+		      this.store.saveSecret(String(res.subscription_id), res.signing_secret);
+		    }
+		  }
+
+		  _parseDelivery(rawBody) {
+		    const event = JSON.parse(_text(rawBody));
+		    for (const key of ['event_id', 'subscription_id', 'target']) {
+		      if (typeof event?.[key] !== 'string' || !event[key]) throw new Error(`missing ${key}`);
+		    }
+		    if (!Number.isInteger(event.photo_id)) throw new Error('photo_id must be an integer');
+		    return event;
+		  }
+
+		  async _dispatch(event) {
+		    if (!this.store.markSeen(String(event.event_id), this.dedupeTtlS)) return 'duplicate';
+		    if (this._onEvent) {
+		      try {
+		        await this._onEvent(event);
+		      } catch (e) {
+		        // release the dedupe claim so the producer's retry redelivers
+		        this.store.unmarkSeen(String(event.event_id));
+		        throw e;
+		      }
+		    }
+		    return 'handled';
+		  }
+		}
+
+		// helpers
+		function selectResultColumns(photo, target) {
+		  if (target === 'all') return null;
+		  const sep = String(target).indexOf(':');
+		  const kind = sep === -1 ? String(target) : String(target).slice(0, sep);
+		  const name = sep === -1 ? '' : String(target).slice(sep + 1);
+		  let columns;
+		  if (kind === 'model') {
+		    columns = WEBHOOK_MODEL_COLUMNS[name];
+		    if (!columns) throw new Error(`unknown model '${name}'`);
+		  } else if (kind === 'outcome') {
+		    const models = WEBHOOK_OUTCOME_MODELS[name];
+		    if (!models) throw new Error(`unknown outcome '${name}'`);
+		    columns = [...new Set(models.flatMap((m) => WEBHOOK_MODEL_COLUMNS[m]))];
+		  } else {
+		    throw new Error(`unknown target grammar '${target}' (expected 'model:<name>', 'outcome:<name>', or 'all')`);
+		  }
+		  const selected = {};
+		  for (const c of columns) selected[c] = photo?.[c] ?? null;
+		  return selected;
+		}
+
+		function _photoPath(projectTableName, photoId) {
+		  return `/api/v1/photos/${encodeURIComponent(projectTableName)}/${encodeURIComponent(String(photoId))}`;
+		}
+
+		function _text(rawBody) {
+		  return typeof rawBody === 'string' ? rawBody : new TextDecoder().decode(toBytes(rawBody));
+		}
+
+		consumer = { WebhookConsumer, selectResultColumns, WEBHOOK_MODEL_COLUMNS, WEBHOOK_OUTCOME_MODELS };
+		return consumer;
+	}
+
 	var src;
 	var hasRequiredSrc;
 
@@ -472,19 +914,19 @@
 		if (hasRequiredSrc) return src;
 		hasRequiredSrc = 1;
 
-		const { OAuthClient } = requireClient();
-		const { OAuthError } = requireErrors();
-		const { OAuthErrorCode } = requireTypes();
+		const { WebhookConsumer, selectResultColumns, WEBHOOK_MODEL_COLUMNS, WEBHOOK_OUTCOME_MODELS } = requireConsumer();
+		const { InMemoryWebhookStore } = requireStore();
+		const { signWebhookPayload, verifyWebhookSignature } = requireSigning();
 
-		src = { OAuthClient, OAuthError, OAuthErrorCode };
+		src = { WebhookConsumer, InMemoryWebhookStore, signWebhookPayload, verifyWebhookSignature, selectResultColumns, WEBHOOK_MODEL_COLUMNS, WEBHOOK_OUTCOME_MODELS };
 		return src;
 	}
 
 	var srcExports = requireSrc();
-	var _oauth = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+	var _webhooks = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
 
 	// Auto-generated — do not edit
-	const { OAuthClient, OAuthError, OAuthErrorCode } = _oauth;
+	const { WebhookConsumer, InMemoryWebhookStore, signWebhookPayload, verifyWebhookSignature, selectResultColumns, WEBHOOK_MODEL_COLUMNS, WEBHOOK_OUTCOME_MODELS } = _webhooks;
 
 	class AiModelCredits {
 	  constructor(ctx) { this._ctx = ctx; }
@@ -531,7 +973,7 @@
 	  }
 	}
 
-	function stripUndef$6(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+	function stripUndef$7(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class CuratedAlbums {
 	  constructor(ctx) { this._ctx = ctx; }
@@ -539,7 +981,7 @@
 	  async createCuratedAlbum(projectTableName, name, description = undefined, confidenceValue = undefined) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/curated_album/project/${encodeURIComponent(projectTableName)}`;
-	    const body = stripUndef$6({
+	    const body = stripUndef$7({
 	      name: name,
 	      description: description,
 	      confidence_value: confidenceValue,
@@ -593,7 +1035,7 @@
 	  async updateCuratedAlbum(albumId, { name, description, confidenceValue } = {}) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/curated_album/${encodeURIComponent(albumId)}`;
-	    const body = stripUndef$6({
+	    const body = stripUndef$7({
 	      name: name,
 	      description: description,
 	      confidence_value: confidenceValue,
@@ -617,7 +1059,7 @@
 	  }
 	}
 
-	function stripUndef$5(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+	function stripUndef$6(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class CustomAlbums {
 	  constructor(ctx) { this._ctx = ctx; }
@@ -665,7 +1107,7 @@
 	  async createProjectCustomAlbum(projectTableName, { name, description, photoIdInclusionList, photoIdRemovalList } = {}) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/custom_album/project/${encodeURIComponent(projectTableName)}`;
-	    const body = stripUndef$5({
+	    const body = stripUndef$6({
 	      name: name,
 	      description: description,
 	      photo_id_inclusion_list: photoIdInclusionList,
@@ -678,7 +1120,7 @@
 	  async updateCustomAlbum(albumId, { name, description, photoIdInclusionList, photoIdRemovalList } = {}) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/custom_album/${encodeURIComponent(albumId)}`;
-	    const body = stripUndef$5({
+	    const body = stripUndef$6({
 	      name: name,
 	      description: description,
 	      photo_id_inclusion_list: photoIdInclusionList,
@@ -778,7 +1220,7 @@
 	  }
 	}
 
-	function stripUndef$4(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+	function stripUndef$5(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class EmailTokens {
 	  constructor(ctx) { this._ctx = ctx; }
@@ -809,7 +1251,7 @@
 	  }
 
 	  async validateToken(token) {
-	    const body = stripUndef$4({
+	    const body = stripUndef$5({
 	      token: token,
 	    });
 	    const resp = await fetch(this._ctx.baseUrl + `/api/v1/validate-token`, {
@@ -821,7 +1263,7 @@
 	  }
 
 	  async resetPassword(token, newPassword) {
-	    const body = stripUndef$4({
+	    const body = stripUndef$5({
 	      token: token,
 	      new_password: newPassword,
 	    });
@@ -860,7 +1302,7 @@
 	  }
 	}
 
-	function stripUndef$3(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+	function stripUndef$4(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class Keywords {
 	  constructor(ctx) { this._ctx = ctx; }
@@ -868,7 +1310,7 @@
 	  async createKeywordFilteringList(name, projectList = undefined) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/keyword/`;
-	    const body = stripUndef$3({
+	    const body = stripUndef$4({
 	      name: name,
 	      project_list: projectList,
 	    });
@@ -921,7 +1363,7 @@
 	  async updateKeywordFilteringListLabels(keywordListId, listKeywordsToInclude, listKeywordsToExclude) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/keyword/${encodeURIComponent(keywordListId)}`;
-	    const body = stripUndef$3({
+	    const body = stripUndef$4({
 	      list_keywords_to_include: listKeywordsToInclude,
 	      list_keywords_to_exclude: listKeywordsToExclude,
 	    });
@@ -932,7 +1374,7 @@
 	  async updateKeywordFilteringListDetails(keywordListId, { name, projectList } = {}) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/keyword/details/${encodeURIComponent(keywordListId)}`;
-	    const body = stripUndef$3({
+	    const body = stripUndef$4({
 	      name: name,
 	      project_list: projectList,
 	    });
@@ -1131,6 +1573,13 @@
 	    return data;
 	  }
 
+	  async removePersonName(projectTableName, personId) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/person/${encodeURIComponent(projectTableName)}/remove_name/${encodeURIComponent(personId)}`;
+	    const { data } = await this._ctx.client.request(path, 'PUT', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
+
 	  async combinePersons(projectTableName, destinationPersonId, oldPersonId) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/person/${encodeURIComponent(projectTableName)}/combine/${encodeURIComponent(destinationPersonId)}/${encodeURIComponent(oldPersonId)}`;
@@ -1181,14 +1630,21 @@
 	    const { data } = await this._ctx.client.request(path, 'GET', this._ctx.accessToken, this._ctx.refreshToken);
 	    return data;
 	  }
+
+	  async removePerson(projectTableName, personId) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/person/${encodeURIComponent(projectTableName)}/${encodeURIComponent(personId)}`;
+	    const { data } = await this._ctx.client.request(path, 'DELETE', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
 	}
 
-	function stripUndef$2(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+	function stripUndef$3(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class Projects {
 	  constructor(ctx) { this._ctx = ctx; }
 
-	  async createProjectAndRun(name, private_ = undefined, type = undefined, description = undefined, directory = undefined, photoUploadVector = undefined, thumbnail = undefined, runName = undefined, { outcomes, models } = {}) {
+	  async createProjectAndRun(name, type, private_ = undefined, description = undefined, directory = undefined, photoUploadVector = undefined, thumbnail = undefined, runName = undefined, { outcomes, models } = {}) {
 	    this._ctx.requireTokens();
 	    let path = `/api/v1/project_outcome/`;
 	    const query = new URLSearchParams();
@@ -1196,7 +1652,7 @@
 	    if (models !== undefined) (Array.isArray(models) ? models : [models]).forEach(v => query.append('models', v));
 	    const qs = query.toString();
 	    if (qs) path += '?' + qs;
-	    const body = stripUndef$2({
+	    const body = stripUndef$3({
 	      name: name,
 	      private: private_,
 	      type: type,
@@ -1266,7 +1722,7 @@
 	  async updateProject(projectId, { private: private_, type, description, directory, name, thumbnail } = {}) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/projects/${encodeURIComponent(projectId)}`;
-	    const body = stripUndef$2({
+	    const body = stripUndef$3({
 	      private: private_,
 	      type: type,
 	      description: description,
@@ -1345,7 +1801,7 @@
 	  async addProjectEvent(projectTableName, event, detail = undefined) {
 	    this._ctx.requireTokens();
 	    const path = `/api/v1/projects/${encodeURIComponent(projectTableName)}/event`;
-	    const body = stripUndef$2({
+	    const body = stripUndef$3({
 	      event: event,
 	      detail: detail,
 	    });
@@ -1489,7 +1945,7 @@
 	  }
 	}
 
-	function stripUndef$1(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+	function stripUndef$2(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class Search {
 	  constructor(ctx) { this._ctx = ctx; }
@@ -1571,7 +2027,7 @@
 	    if (splitByTier !== undefined) (Array.isArray(splitByTier) ? splitByTier : [splitByTier]).forEach(v => query.append('split_by_tier', v));
 	    const qs = query.toString();
 	    if (qs) path += '?' + qs;
-	    const body = stripUndef$1({
+	    const body = stripUndef$2({
 	      search_text: searchText,
 	      size: size,
 	    });
@@ -1627,6 +2083,75 @@
 	  }
 	}
 
+	function stripUndef$1(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
+
+	class Subscription {
+	  constructor(ctx) { this._ctx = ctx; }
+
+	  async createSubscription(projectTableName, callbackUrl, targets) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/subscriptions`;
+	    const body = stripUndef$1({
+	      project_table_name: projectTableName,
+	      callback_url: callbackUrl,
+	      targets: targets,
+	    });
+	    const { data } = await this._ctx.client.request(path, 'POST', this._ctx.accessToken, this._ctx.refreshToken, body);
+	    return data;
+	  }
+
+	  async verifySubscription(subscriptionId) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/subscriptions/${encodeURIComponent(subscriptionId)}/verify`;
+	    const { data } = await this._ctx.client.request(path, 'POST', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
+
+	  async listSubscriptions() {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/subscriptions`;
+	    const { data } = await this._ctx.client.request(path, 'GET', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
+
+	  async listSubscriptionEvents(subscriptionId, { since, limit } = {}) {
+	    this._ctx.requireTokens();
+	    let path = `/api/v1/subscriptions/${encodeURIComponent(subscriptionId)}/events`;
+	    const query = new URLSearchParams();
+	    if (since !== undefined) (Array.isArray(since) ? since : [since]).forEach(v => query.append('since', v));
+	    if (limit !== undefined) (Array.isArray(limit) ? limit : [limit]).forEach(v => query.append('limit', v));
+	    const qs = query.toString();
+	    if (qs) path += '?' + qs;
+	    const { data } = await this._ctx.client.request(path, 'GET', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
+
+	  async updateSubscription(subscriptionId, { callbackUrl, targets } = {}) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/subscriptions/${encodeURIComponent(subscriptionId)}`;
+	    const body = stripUndef$1({
+	      callback_url: callbackUrl,
+	      targets: targets,
+	    });
+	    const { data } = await this._ctx.client.request(path, 'PATCH', this._ctx.accessToken, this._ctx.refreshToken, body);
+	    return data;
+	  }
+
+	  async deleteSubscription(subscriptionId) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/subscriptions/${encodeURIComponent(subscriptionId)}`;
+	    const { data } = await this._ctx.client.request(path, 'DELETE', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
+
+	  async rotateSubscriptionSecret(subscriptionId) {
+	    this._ctx.requireTokens();
+	    const path = `/api/v1/subscriptions/${encodeURIComponent(subscriptionId)}/rotate_secret`;
+	    const { data } = await this._ctx.client.request(path, 'POST', this._ctx.accessToken, this._ctx.refreshToken);
+	    return data;
+	  }
+	}
+
 	function stripUndef(o) { const r = {}; for (const k in o) if (o[k] !== undefined) r[k] = o[k]; return r; }
 
 	class Users {
@@ -1810,7 +2335,9 @@
 	    this.photos = new Photos(_ctx);
 	    this.projects = new Projects(_ctx);
 	    this.search = new Search(_ctx);
+	    this.subscription = new Subscription(_ctx);
 	    this.users = new Users(_ctx);
+	    this.webhooks = new WebhookConsumer(_ctx, this.subscription);
 	  }
 
 	  async authenticate() {
@@ -1848,6 +2375,7 @@
 	exports.CustomAlbums = CustomAlbums;
 	exports.EmailTokens = EmailTokens;
 	exports.Health = Health;
+	exports.InMemoryWebhookStore = InMemoryWebhookStore;
 	exports.Keywords = Keywords;
 	exports.MediaViz = MediaViz;
 	exports.NotFoundError = NotFoundError;
@@ -1864,8 +2392,15 @@
 	exports.RateLimitError = RateLimitError;
 	exports.Search = Search;
 	exports.ServerError = ServerError;
+	exports.Subscription = Subscription;
 	exports.Users = Users;
 	exports.ValidationError = ValidationError;
+	exports.WEBHOOK_MODEL_COLUMNS = WEBHOOK_MODEL_COLUMNS;
+	exports.WEBHOOK_OUTCOME_MODELS = WEBHOOK_OUTCOME_MODELS;
+	exports.WebhookConsumer = WebhookConsumer;
 	exports.handleResponse = handleResponse;
+	exports.selectResultColumns = selectResultColumns;
+	exports.signWebhookPayload = signWebhookPayload;
+	exports.verifyWebhookSignature = verifyWebhookSignature;
 
 }));