@tritonium/api-client 2.1.0

package/dist/index.js

@@ -0,0 +1,3045 @@
+'use strict';
+
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+
+// core/ApiError.ts
+var ApiError = class extends Error {
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var _isResolved, _isRejected, _isCancelled, _cancelHandlers, _promise, _resolve, _reject;
+var CancelablePromise = class {
+  constructor(executor) {
+    __privateAdd(this, _isResolved);
+    __privateAdd(this, _isRejected);
+    __privateAdd(this, _isCancelled);
+    __privateAdd(this, _cancelHandlers);
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolve);
+    __privateAdd(this, _reject);
+    __privateSet(this, _isResolved, false);
+    __privateSet(this, _isRejected, false);
+    __privateSet(this, _isCancelled, false);
+    __privateSet(this, _cancelHandlers, []);
+    __privateSet(this, _promise, new Promise((resolve2, reject) => {
+      __privateSet(this, _resolve, resolve2);
+      __privateSet(this, _reject, reject);
+      const onResolve = (value) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isResolved, true);
+        if (__privateGet(this, _resolve)) __privateGet(this, _resolve).call(this, value);
+      };
+      const onReject = (reason) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isRejected, true);
+        if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateGet(this, _cancelHandlers).push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => __privateGet(this, _isResolved)
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => __privateGet(this, _isRejected)
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => __privateGet(this, _isCancelled)
+      });
+      return executor(onResolve, onReject, onCancel);
+    }));
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return __privateGet(this, _promise).then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return __privateGet(this, _promise).catch(onRejected);
+  }
+  finally(onFinally) {
+    return __privateGet(this, _promise).finally(onFinally);
+  }
+  cancel() {
+    if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+      return;
+    }
+    __privateSet(this, _isCancelled, true);
+    if (__privateGet(this, _cancelHandlers).length) {
+      try {
+        for (const cancelHandler of __privateGet(this, _cancelHandlers)) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    __privateGet(this, _cancelHandlers).length = 0;
+    if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return __privateGet(this, _isCancelled);
+  }
+};
+_isResolved = new WeakMap();
+_isRejected = new WeakMap();
+_isCancelled = new WeakMap();
+_cancelHandlers = new WeakMap();
+_promise = new WeakMap();
+_resolve = new WeakMap();
+_reject = new WeakMap();
+
+// core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "https://api.tritonium.com",
+  VERSION: "1.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// auth.ts
+function configureApiKey(apiKey, baseUrl = "https://api.tritonium.com") {
+  OpenAPI.BASE = baseUrl;
+  const existingHeaders = typeof OpenAPI.HEADERS === "object" && OpenAPI.HEADERS !== null ? OpenAPI.HEADERS : {};
+  OpenAPI.HEADERS = {
+    ...existingHeaders,
+    "X-API-Key": apiKey
+  };
+  if (OpenAPI.TOKEN) {
+    OpenAPI.TOKEN = void 0;
+  }
+}
+function configureBearerToken(token, baseUrl = "https://api.tritonium.com") {
+  OpenAPI.BASE = baseUrl;
+  OpenAPI.TOKEN = token;
+  if (OpenAPI.HEADERS && "X-API-Key" in OpenAPI.HEADERS) {
+    const { "X-API-Key": _, ...rest } = OpenAPI.HEADERS;
+    OpenAPI.HEADERS = rest;
+  }
+}
+function configure(config) {
+  if (config.baseUrl) {
+    OpenAPI.BASE = config.baseUrl;
+  }
+  if (config.apiKey) {
+    OpenAPI.HEADERS = {
+      ...OpenAPI.HEADERS,
+      ...config.headers,
+      "X-API-Key": config.apiKey
+    };
+    OpenAPI.TOKEN = void 0;
+  } else if (config.token) {
+    OpenAPI.TOKEN = config.token;
+    OpenAPI.HEADERS = {
+      ...OpenAPI.HEADERS,
+      ...config.headers
+    };
+  } else if (config.headers) {
+    OpenAPI.HEADERS = {
+      ...OpenAPI.HEADERS,
+      ...config.headers
+    };
+  }
+}
+function getConfiguration() {
+  const headers = OpenAPI.HEADERS;
+  const hasApiKey = typeof headers === "object" && headers !== null && "X-API-Key" in headers;
+  return {
+    baseUrl: OpenAPI.BASE,
+    hasApiKey,
+    hasToken: Boolean(OpenAPI.TOKEN)
+  };
+}
+function clearAuth() {
+  OpenAPI.TOKEN = void 0;
+  const headers = OpenAPI.HEADERS;
+  if (typeof headers === "object" && headers !== null && "X-API-Key" in headers) {
+    const { "X-API-Key": _, ...rest } = headers;
+    OpenAPI.HEADERS = rest;
+  }
+}
+var WebhookVerificationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookVerificationError";
+  }
+};
+var WebhookExpiredError = class extends WebhookVerificationError {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookExpiredError";
+  }
+};
+var WebhookSignatureError = class extends WebhookVerificationError {
+  constructor(message) {
+    super(message);
+    this.name = "WebhookSignatureError";
+  }
+};
+var EventTypes = {
+  CRISIS_DETECTED: "crisis.detected",
+  INSIGHT_GENERATED: "insight.generated",
+  REVIEW_RECEIVED: "review.received",
+  ANALYSIS_COMPLETED: "analysis.completed",
+  ALERT_TRIGGERED: "alert.triggered",
+  TEST_PING: "test.ping"
+};
+function verifySignature(payload, signature, secret) {
+  const payloadBuffer = typeof payload === "string" ? Buffer.from(payload) : payload;
+  const receivedSig = signature.startsWith("sha256=") ? signature.slice(7) : signature;
+  const expectedSig = crypto__namespace.createHmac("sha256", secret).update(payloadBuffer).digest("hex");
+  try {
+    return crypto__namespace.timingSafeEqual(
+      Buffer.from(receivedSig),
+      Buffer.from(expectedSig)
+    );
+  } catch {
+    return false;
+  }
+}
+function verifyTimestamp(timestamp, toleranceSeconds = 300) {
+  try {
+    const webhookTime = new Date(timestamp).getTime();
+    const now = Date.now();
+    const ageMs = Math.abs(now - webhookTime);
+    return ageMs <= toleranceSeconds * 1e3;
+  } catch {
+    return false;
+  }
+}
+function verifyWebhook(options) {
+  const { payload, signature, timestamp, secret, toleranceSeconds = 300 } = options;
+  if (!verifyTimestamp(timestamp, toleranceSeconds)) {
+    throw new WebhookExpiredError(
+      `Webhook timestamp is too old or invalid: ${timestamp}`
+    );
+  }
+  if (!verifySignature(payload, signature, secret)) {
+    throw new WebhookSignatureError("Invalid webhook signature");
+  }
+  let data;
+  try {
+    const payloadStr = typeof payload === "string" ? payload : payload.toString("utf-8");
+    data = JSON.parse(payloadStr);
+  } catch (e) {
+    throw new WebhookVerificationError(`Invalid webhook payload: ${e}`);
+  }
+  let eventTimestamp;
+  try {
+    eventTimestamp = new Date(
+      data.timestamp || timestamp
+    );
+  } catch {
+    eventTimestamp = /* @__PURE__ */ new Date();
+  }
+  return {
+    eventId: data.event_id || "",
+    eventType: data.event_type || "",
+    timestamp: eventTimestamp,
+    tenantId: data.tenant_id || "",
+    appUuid: data.app_uuid,
+    data: data.data || {},
+    rawPayload: data
+  };
+}
+var constructEvent = verifyWebhook;
+function isWebhookError(error) {
+  return error instanceof WebhookVerificationError;
+}
+
+// models/Alert.ts
+exports.Alert = void 0;
+((Alert2) => {
+  ((severity2) => {
+    severity2["CRITICAL"] = "critical";
+    severity2["HIGH"] = "high";
+    severity2["MEDIUM"] = "medium";
+    severity2["LOW"] = "low";
+  })(Alert2.severity || (Alert2.severity = {}));
+  ((status2) => {
+    status2["UNREAD"] = "unread";
+    status2["READ"] = "read";
+    status2["ACKNOWLEDGED"] = "acknowledged";
+    status2["SNOOZED"] = "snoozed";
+  })(Alert2.status || (Alert2.status = {}));
+})(exports.Alert || (exports.Alert = {}));
+
+// models/AlertUpdateRequest.ts
+exports.AlertUpdateRequest = void 0;
+((AlertUpdateRequest2) => {
+  ((status2) => {
+    status2["UNREAD"] = "unread";
+    status2["READ"] = "read";
+    status2["ACKNOWLEDGED"] = "acknowledged";
+    status2["SNOOZED"] = "snoozed";
+  })(AlertUpdateRequest2.status || (AlertUpdateRequest2.status = {}));
+})(exports.AlertUpdateRequest || (exports.AlertUpdateRequest = {}));
+
+// models/AutoSyncConfigRequest.ts
+exports.AutoSyncConfigRequest = void 0;
+((AutoSyncConfigRequest2) => {
+  ((frequency2) => {
+    frequency2["HOURLY"] = "hourly";
+    frequency2["DAILY"] = "daily";
+    frequency2["WEEKLY"] = "weekly";
+  })(AutoSyncConfigRequest2.frequency || (AutoSyncConfigRequest2.frequency = {}));
+})(exports.AutoSyncConfigRequest || (exports.AutoSyncConfigRequest = {}));
+
+// core/request.ts
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const jsonTypes = ["application/json", "application/problem+json"];
+        const isJSON = jsonTypes.some((type) => contentType.toLowerCase().startsWith(type));
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// services/AlertsService.ts
+var AlertsService = class {
+  /**
+   * List alert notifications for the tenant.
+   * @param limit
+   * @param cursor
+   * @param severity
+   * @param status
+   * @returns any Alerts returned.
+   * @throws ApiError
+   */
+  static getAlerts(limit, cursor, severity, status) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/alerts",
+      query: {
+        "limit": limit,
+        "cursor": cursor,
+        "severity": severity,
+        "status": status
+      },
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Retrieve alert details.
+   * @param alertId
+   * @returns Alert Alert returned.
+   * @throws ApiError
+   */
+  static getAlert(alertId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/alerts/{alertId}",
+      path: {
+        "alertId": alertId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Update alert status or acknowledgement metadata.
+   * @param alertId
+   * @param requestBody
+   * @returns Alert Alert updated.
+   * @throws ApiError
+   */
+  static patchAlert(alertId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/api/v1/alerts/{alertId}",
+      path: {
+        "alertId": alertId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Assign an alert to a team member.
+   * Assigns the specified alert to a team member for follow-up. Used by the alerts PWA for delegation workflows.
+   * @param alertId
+   * @param requestBody
+   * @returns GenericSuccess Alert assigned successfully.
+   * @throws ApiError
+   */
+  static postAlertAssign(alertId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/alerts/{alertId}/assign",
+      path: {
+        "alertId": alertId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+};
+
+// services/AppsService.ts
+var AppsService = class {
+  /**
+   * List apps connected to the current tenant.
+   * @returns any Apps retrieved.
+   * @throws ApiError
+   */
+  static getApps() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect a new app using stored credentials.
+   * @param requestBody
+   * @returns AppSummary App connected.
+   * @throws ApiError
+   */
+  static postAppsConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Alias endpoint for connecting apps.
+   * @param requestBody
+   * @returns AppSummary App connected.
+   * @throws ApiError
+   */
+  static postAppsConnectAlias(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Trigger an on-demand review sync for a specific app.
+   * @param requestBody
+   * @returns GenericSuccess Sync job queued.
+   * @throws ApiError
+   */
+  static postAppsSync(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/sync",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Queue AI-powered analysis for an app.
+   * @param requestBody
+   * @returns any Analysis queued or cached result returned.
+   * @throws ApiError
+   */
+  static postAppsAnalyze(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/analyze",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Update automatic review sync settings.
+   * @param appUuid
+   * @param requestBody
+   * @returns any Auto-sync settings updated.
+   * @throws ApiError
+   */
+  static patchAppAutoSync(appUuid, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/api/v1/apps/{appUuid}/auto-sync",
+      path: {
+        "appUuid": appUuid
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Enable or disable automatic review sync.
+   * @param appUuid
+   * @param requestBody
+   * @returns any Auto-sync settings updated.
+   * @throws ApiError
+   */
+  static postAppAutoSync(appUuid, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/{appUuid}/auto-sync",
+      path: {
+        "appUuid": appUuid
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * List competitor apps registered for benchmarking.
+   * @param appUuid
+   * @returns any Competitors returned.
+   * @throws ApiError
+   */
+  static getCompetitors(appUuid) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/competitors",
+      path: {
+        "appUuid": appUuid
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Register a competitor app.
+   * @param appUuid
+   * @param requestBody
+   * @returns Competitor Competitor registered.
+   * @throws ApiError
+   */
+  static postCompetitor(appUuid, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/{appUuid}/competitors",
+      path: {
+        "appUuid": appUuid
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Remove a competitor mapping.
+   * @param appUuid
+   * @param platform
+   * @param externalAppId
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteCompetitor(appUuid, platform, externalAppId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/apps/{appUuid}/competitors/{platform}/{externalAppId}",
+      path: {
+        "appUuid": appUuid,
+        "platform": platform,
+        "externalAppId": externalAppId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Historical feature impact entries for an app release.
+   * @param appUuid
+   * @param limit
+   * @param cursor
+   * @returns any Feature history returned.
+   * @throws ApiError
+   */
+  static getFeatureHistory(appUuid, limit, cursor) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/features/history",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+};
+
+// services/AuthService.ts
+var AuthService = class {
+  /**
+   * Register a new workspace owner.
+   * @param requestBody
+   * @returns GenericSuccess Registration accepted.
+   * @throws ApiError
+   */
+  static postRegister(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/register",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        409: `Resource already exists or is in conflict.`
+      }
+    });
+  }
+  /**
+   * Confirm email verification token.
+   * @param requestBody
+   * @returns GenericSuccess Email verified.
+   * @throws ApiError
+   */
+  static postVerifyEmail(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/verify-email",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        410: `Token expired or resource no longer available.`
+      }
+    });
+  }
+  /**
+   * Trigger a new verification email.
+   * @param requestBody
+   * @returns GenericSuccess Verification email queued.
+   * @throws ApiError
+   */
+  static postResendVerification(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/resend-verification",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Request a password reset email.
+   * @param requestBody
+   * @returns GenericSuccess Reset email dispatched.
+   * @throws ApiError
+   */
+  static postForgotPassword(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/forgot-password",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Reset password with a valid token.
+   * @param requestBody
+   * @returns GenericSuccess Password updated.
+   * @throws ApiError
+   */
+  static postResetPassword(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/reset-password",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        410: `Token expired or resource no longer available.`
+      }
+    });
+  }
+  /**
+   * Authenticate via email and password.
+   * @param requestBody
+   * @returns any Login successful.
+   * @throws ApiError
+   */
+  static postLogin(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/login",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Complete Google Workspace SSO exchange.
+   * @param requestBody
+   * @returns any Google SSO successful.
+   * @throws ApiError
+   */
+  static postGoogleSso(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/google/sso",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Complete Microsoft Entra ID SSO exchange.
+   * @param requestBody
+   * @returns any Microsoft SSO successful.
+   * @throws ApiError
+   */
+  static postMicrosoftSso(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/auth/microsoft/sso",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+};
+
+// services/BillingService.ts
+var BillingService = class {
+  /**
+   * Create a Stripe Checkout session.
+   * @param requestBody
+   * @returns any Checkout session created.
+   * @throws ApiError
+   */
+  static postBillingCheckout(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/checkout",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Retrieve current subscription details.
+   * @returns Subscription Subscription returned.
+   * @throws ApiError
+   */
+  static getSubscription() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/subscription",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Retrieve per-integration subscription details.
+   * @returns any Per-integration subscription returned.
+   * @throws ApiError
+   */
+  static getSubscriptionV2() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/subscription-v2",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Cancel the active subscription at period end.
+   * @returns Subscription Subscription cancellation scheduled.
+   * @throws ApiError
+   */
+  static postCancelSubscription() {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/cancel-subscription",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Reactivate a cancelled subscription.
+   * @returns Subscription Subscription reactivated.
+   * @throws ApiError
+   */
+  static postReactivateSubscription() {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/reactivate-subscription",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Attach or update a default payment method.
+   * @param requestBody
+   * @returns Subscription Payment method updated.
+   * @throws ApiError
+   */
+  static postPaymentMethod(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/payment-method",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * List invoices for the tenant.
+   * @param limit
+   * @param cursor
+   * @returns any Invoices returned.
+   * @throws ApiError
+   */
+  static getInvoices(limit, cursor) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/invoices",
+      query: {
+        "limit": limit,
+        "cursor": cursor
+      },
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Stripe webhook endpoint.
+   * @param requestBody
+   * @returns any Event processed.
+   * @throws ApiError
+   */
+  static postBillingWebhook(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/webhooks",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Calculate per-integration pricing totals.
+   * @param requestBody
+   * @returns any Pricing calculated.
+   * @throws ApiError
+   */
+  static postCalculatePricing(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/calculate-pricing",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Create per-integration subscription.
+   * @param requestBody
+   * @returns any Subscription created.
+   * @throws ApiError
+   */
+  static postCreateSubscriptionV2(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/create-subscription-v2",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        402: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Update per-integration subscription quantities.
+   * @param requestBody
+   * @returns any Subscription updated.
+   * @throws ApiError
+   */
+  static postUpdateSubscriptionV2(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/update-subscription-v2",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        402: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Migrate legacy subscriptions to per-integration pricing.
+   * @param requestBody
+   * @returns any Migration initiated.
+   * @throws ApiError
+   */
+  static postMigrateSubscription(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/migrate-subscription",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        402: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Calculate regional pricing based on country.
+   * Returns pricing information adjusted for purchasing power parity (PPP) based on the provided country code. Discounts range from 0% (US/UK/EU) to 60% for developing economies.
+   * @param requestBody
+   * @returns any Regional pricing calculated.
+   * @throws ApiError
+   */
+  static postRegionalPricing(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/billing/regional-pricing",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Detect user's country from IP address.
+   * Detects the user's country based on their IP address for display purposes. Note: Final pricing is always determined by card country, not IP location.
+   * @returns any Country detected successfully.
+   * @throws ApiError
+   */
+  static getDetectCountry() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/detect-country",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Get usage dashboard data.
+   * Returns comprehensive usage data for the current billing period including apps, members, syncs, and cost projections.
+   * @returns any Usage dashboard data returned.
+   * @throws ApiError
+   */
+  static getUsageDashboard() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/usage-dashboard",
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Get bill forecast data.
+   * Returns projected billing amounts over a specified horizon (7d, 30d, or 90d) with confidence intervals.
+   * @param horizon Forecast horizon
+   * @returns any Bill forecast returned.
+   * @throws ApiError
+   */
+  static getBillForecast(horizon = "30d") {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/bill-forecast",
+      query: {
+        "horizon": horizon
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Get pricing information.
+   * Returns the current pricing model and rates.
+   * @returns any Pricing information returned.
+   * @throws ApiError
+   */
+  static getPricing() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/billing/pricing",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+};
+
+// services/CredentialsService.ts
+var CredentialsService = class {
+  /**
+   * List stored credentials for the tenant.
+   * @returns any Credentials returned.
+   * @throws ApiError
+   */
+  static getCredentials() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/credentials",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Store a new credential set.
+   * @param requestBody
+   * @returns Credential Credential stored.
+   * @throws ApiError
+   */
+  static postCredential(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/credentials",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Retrieve credential details by ID.
+   * @param credentialId
+   * @returns Credential Credential returned.
+   * @throws ApiError
+   */
+  static getCredential(credentialId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/credentials/{credentialId}",
+      path: {
+        "credentialId": credentialId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Update an existing credential.
+   * @param credentialId
+   * @param requestBody
+   * @returns Credential Credential updated.
+   * @throws ApiError
+   */
+  static putCredential(credentialId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/api/v1/credentials/{credentialId}",
+      path: {
+        "credentialId": credentialId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Delete a credential.
+   * @param credentialId
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteCredential(credentialId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/credentials/{credentialId}",
+      path: {
+        "credentialId": credentialId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * List apps linked to a credential.
+   * @param credentialId
+   * @returns any Linked apps returned.
+   * @throws ApiError
+   */
+  static getCredentialApps(credentialId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/credentials/{credentialId}/apps",
+      path: {
+        "credentialId": credentialId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Validate credential authenticity with source systems.
+   * @param requestBody
+   * @returns GenericSuccess Validation outcome.
+   * @throws ApiError
+   */
+  static postCredentialValidate(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/credentials/validate",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+};
+
+// services/HealthService.ts
+var HealthService = class {
+  /**
+   * Check API availability.
+   * @returns any API is reachable.
+   * @throws ApiError
+   */
+  static getHealth() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/health",
+      errors: {
+        500: `Unexpected server error.`
+      }
+    });
+  }
+  /**
+   * Root health probe.
+   * @returns any API is reachable.
+   * @throws ApiError
+   */
+  static getRoot() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/",
+      errors: {
+        500: `Unexpected server error.`
+      }
+    });
+  }
+};
+
+// services/InsightsService.ts
+var InsightsService = class {
+  /**
+   * Queue AI-powered analysis for an app.
+   * @param requestBody
+   * @returns any Analysis queued or cached result returned.
+   * @throws ApiError
+   */
+  static postAppsAnalyze(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/analyze",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Aggregate reply performance metrics for an app.
+   * @param appUuid
+   * @returns ReplyAnalytics Reply analytics returned.
+   * @throws ApiError
+   */
+  static getReplyAnalytics(appUuid) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/replies/analytics",
+      path: {
+        "appUuid": appUuid
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Retrieve the latest insight bundle for an app.
+   * @param appUuid
+   * @returns Insight Insight bundle retrieved.
+   * @throws ApiError
+   */
+  static getAppInsights(appUuid) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/insights",
+      path: {
+        "appUuid": appUuid
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Historical insight summaries for an app.
+   * @param appUuid
+   * @param limit
+   * @param cursor
+   * @returns any Insight history returned.
+   * @throws ApiError
+   */
+  static getAppInsightHistory(appUuid, limit, cursor) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/insights/history",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Historical feature impact entries for an app release.
+   * @param appUuid
+   * @param limit
+   * @param cursor
+   * @returns any Feature history returned.
+   * @throws ApiError
+   */
+  static getFeatureHistory(appUuid, limit, cursor) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/features/history",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Tenant-level feed of insight highlights.
+   * @param limit
+   * @param cursor
+   * @returns any Insights returned.
+   * @throws ApiError
+   */
+  static getTenantInsights(limit, cursor) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/insights",
+      query: {
+        "limit": limit,
+        "cursor": cursor
+      },
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * List reviewer segments for an app.
+   * @param appUuid App UUID assigned by Tritonium.
+   * @param segmentType
+   * @param sort
+   * @param limit
+   * @returns any Segments returned.
+   * @throws ApiError
+   */
+  static getAppSegments(appUuid, segmentType, sort, limit) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{app_uuid}/segments",
+      path: {
+        "app_uuid": appUuid
+      },
+      query: {
+        "segment_type": segmentType,
+        "sort": sort,
+        "limit": limit
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Retrieve reviews tied to a specific segment.
+   * @param appUuid App UUID assigned by Tritonium.
+   * @param segmentType
+   * @returns any Reviews returned.
+   * @throws ApiError
+   */
+  static getSegmentReviews(appUuid, segmentType) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{app_uuid}/segments/{segment_type}/reviews",
+      path: {
+        "app_uuid": appUuid,
+        "segment_type": segmentType
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * List reviews with viral engagement.
+   * @param appUuid App UUID assigned by Tritonium.
+   * @param lookbackHours
+   * @param minEngagement
+   * @param sentiment
+   * @returns any Viral review payload.
+   * @throws ApiError
+   */
+  static getViralReviews(appUuid, lookbackHours = 48, minEngagement = 50, sentiment) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{app_uuid}/reviews/viral",
+      path: {
+        "app_uuid": appUuid
+      },
+      query: {
+        "lookback_hours": lookbackHours,
+        "min_engagement": minEngagement,
+        "sentiment": sentiment
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Retrieve engagement history for a review.
+   * @param reviewId
+   * @param appUuid
+   * @returns any History returned.
+   * @throws ApiError
+   */
+  static getReviewEngagementHistory(reviewId, appUuid) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reviews/{review_id}/engagement/history",
+      path: {
+        "review_id": reviewId
+      },
+      query: {
+        "app_uuid": appUuid
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * List reply template performance metrics.
+   * @param days
+   * @param templateId
+   * @returns any Template analytics returned.
+   * @throws ApiError
+   */
+  static getTemplatePerformance(days = 90, templateId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reply-templates/performance",
+      query: {
+        "days": days,
+        "template_id": templateId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Alias for template performance listing.
+   * @returns any Template analytics returned.
+   * @throws ApiError
+   */
+  static getTemplateComparison() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reply-templates/comparison",
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+};
+
+// services/IntegrationsService.ts
+var IntegrationsService = class {
+  /**
+   * List configured integrations.
+   * @returns any Integrations returned.
+   * @throws ApiError
+   */
+  static getIntegrations() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Retrieve integration configuration.
+   * @param integrationId
+   * @returns Integration Integration returned.
+   * @throws ApiError
+   */
+  static getIntegration(integrationId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations/{integrationId}",
+      path: {
+        "integrationId": integrationId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Update mutable integration metadata.
+   * @param integrationId
+   * @param requestBody
+   * @returns Integration Integration updated.
+   * @throws ApiError
+   */
+  static patchIntegration(integrationId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/api/v1/integrations/{integrationId}",
+      path: {
+        "integrationId": integrationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Delete an integration configuration.
+   * @param integrationId
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteIntegration(integrationId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/integrations/{integrationId}",
+      path: {
+        "integrationId": integrationId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Send a test payload for an integration.
+   * @param integrationId
+   * @param requestBody
+   * @returns GenericSuccess Test executed.
+   * @throws ApiError
+   */
+  static postIntegrationTest(integrationId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/{integrationId}/test",
+      path: {
+        "integrationId": integrationId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Start Jira OAuth connection.
+   * @param requestBody
+   * @returns Integration Authorization URL or status returned.
+   * @throws ApiError
+   */
+  static postJiraConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/jira/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Complete Jira OAuth exchange.
+   * @param state
+   * @param code
+   * @returns Integration Jira integration connected.
+   * @throws ApiError
+   */
+  static getJiraCallback(state, code) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations/jira/callback",
+      query: {
+        "state": state,
+        "code": code
+      },
+      errors: {
+        400: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Push an incident update to Jira.
+   * @param requestBody
+   * @returns GenericSuccess Issue created or updated.
+   * @throws ApiError
+   */
+  static postJiraIncident(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/jira/post",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect Linear workspace.
+   * @param requestBody
+   * @returns Integration Linear integration configured.
+   * @throws ApiError
+   */
+  static postLinearConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/linear/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect Discord notifications.
+   * @param requestBody
+   * @returns Integration Discord integration configured.
+   * @throws ApiError
+   */
+  static postDiscordConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/discord/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect Microsoft Teams notifications.
+   * @param requestBody
+   * @returns Integration Teams integration configured.
+   * @throws ApiError
+   */
+  static postTeamsConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/teams/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Start Help Scout OAuth flow.
+   * @param requestBody
+   * @returns GenericSuccess Authorization URL generated.
+   * @throws ApiError
+   */
+  static postHelpScoutStart(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/helpscout/start",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Complete Help Scout OAuth exchange.
+   * @param requestBody
+   * @returns Integration Help Scout integration connected.
+   * @throws ApiError
+   */
+  static postHelpScoutConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/helpscout/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Start Salesforce OAuth flow.
+   * @param requestBody
+   * @returns GenericSuccess Authorization URL generated.
+   * @throws ApiError
+   */
+  static postSalesforceStart(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/salesforce/start",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Complete Salesforce OAuth exchange.
+   * @param requestBody
+   * @returns Integration Salesforce integration connected.
+   * @throws ApiError
+   */
+  static postSalesforceConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/salesforce/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Start Zendesk OAuth flow.
+   * @param requestBody
+   * @returns GenericSuccess Authorization URL generated.
+   * @throws ApiError
+   */
+  static postZendeskStart(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/zendesk/start",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Complete Zendesk OAuth exchange.
+   * @param requestBody
+   * @returns Integration Zendesk integration connected.
+   * @throws ApiError
+   */
+  static postZendeskConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/zendesk/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect Asana workspace.
+   * @param requestBody
+   * @returns Integration Asana integration connected.
+   * @throws ApiError
+   */
+  static postAsanaConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/asana/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect ClickUp workspace.
+   * @param requestBody
+   * @returns Integration ClickUp integration connected.
+   * @throws ApiError
+   */
+  static postClickUpConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/clickup/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect Trello workspace.
+   * @param requestBody
+   * @returns Integration Trello integration connected.
+   * @throws ApiError
+   */
+  static postTrelloConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/trello/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Save Zapier webhook destination.
+   * @param requestBody
+   * @returns Integration Zapier webhook registered.
+   * @throws ApiError
+   */
+  static postZapierConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/zapier/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Configure SMS delivery integration.
+   * @param requestBody
+   * @returns Integration SMS integration configured.
+   * @throws ApiError
+   */
+  static postSmsConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/sms/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Connect GitLab project.
+   * @param requestBody
+   * @returns Integration GitLab integration connected.
+   * @throws ApiError
+   */
+  static postGitlabConnect(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/gitlab/connect",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Start Slack OAuth flow.
+   * @param redirectUri
+   * @returns GenericSuccess Authorization URL generated.
+   * @throws ApiError
+   */
+  static getSlackConnect(redirectUri) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations/slack/connect",
+      query: {
+        "redirect_uri": redirectUri
+      },
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Complete Slack OAuth exchange.
+   * @param code
+   * @param state
+   * @returns Integration Slack workspace connected.
+   * @throws ApiError
+   */
+  static getSlackCallback(code, state) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations/slack/callback",
+      query: {
+        "code": code,
+        "state": state
+      },
+      errors: {
+        400: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Retrieve Slack integration status.
+   * @returns Integration Slack status returned.
+   * @throws ApiError
+   */
+  static getSlackStatus() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations/slack/status",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * List Slack channels available to the app.
+   * @returns any Channel listing returned.
+   * @throws ApiError
+   */
+  static getSlackChannels() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/integrations/slack/channels",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Save the default Slack channel for alerts.
+   * @param requestBody
+   * @returns Integration Channel saved.
+   * @throws ApiError
+   */
+  static postSlackChannel(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/slack/channel",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Send a test Slack notification.
+   * @returns GenericSuccess Test notification sent.
+   * @throws ApiError
+   */
+  static postSlackTest() {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/slack/test",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Post a custom alert message to Slack.
+   * @param requestBody
+   * @returns GenericSuccess Message posted.
+   * @throws ApiError
+   */
+  static postSlackMessage(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/slack/post",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Disconnect Slack workspace.
+   * @returns GenericSuccess Slack integration disabled.
+   * @throws ApiError
+   */
+  static postSlackDisconnect() {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/integrations/slack/disconnect",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+};
+
+// services/InternalService.ts
+var InternalService = class {
+  /**
+   * Health probe for scheduled trial reminder execution.
+   * @returns any Automation healthy.
+   * @throws ApiError
+   */
+  static headTrialReminders() {
+    return request(OpenAPI, {
+      method: "HEAD",
+      url: "/api/v1/internal/run-trial-reminders",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Execute trial reminder workflow.
+   * @returns any Workflow started.
+   * @throws ApiError
+   */
+  static postTrialReminders() {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/internal/run-trial-reminders",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Trigger nightly auto-sync job across apps.
+   * @param requestBody
+   * @returns any Job accepted.
+   * @throws ApiError
+   */
+  static postInternalAutoSync(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/internal/auto-sync",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Perform competitor metadata sync.
+   * @param requestBody
+   * @returns any Sync started.
+   * @throws ApiError
+   */
+  static postInternalCompetitorSync(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/internal/competitors/sync",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Aggregate metrics into dashboards.
+   * @param requestBody
+   * @returns any Aggregation started.
+   * @throws ApiError
+   */
+  static postInternalMetricsAggregate(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/internal/metrics/aggregate",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+};
+
+// services/PredictionsService.ts
+var PredictionsService = class {
+  /**
+   * Retrieve rating forecasts for an app.
+   * @param appUuid
+   * @param horizonDays
+   * @returns PredictionResponse Forecast returned.
+   * @throws ApiError
+   */
+  static getRatingForecast(appUuid, horizonDays) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/predictions/rating-forecast",
+      query: {
+        "app_uuid": appUuid,
+        "horizon_days": horizonDays
+      },
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Compute predicted driver impact for product features.
+   * @param requestBody
+   * @returns PredictionResponse Feature impact predicted.
+   * @throws ApiError
+   */
+  static postFeatureImpactPrediction(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/predictions/feature-impact",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        503: `Upstream model temporarily unavailable.`
+      }
+    });
+  }
+  /**
+   * Predict severity for issues detected in reviews.
+   * @param requestBody
+   * @returns PredictionResponse Severity predictions returned.
+   * @throws ApiError
+   */
+  static postIssueSeverityPrediction(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/predictions/issue-severity",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        503: `Upstream model temporarily unavailable.`
+      }
+    });
+  }
+  /**
+   * Retrieve AI analysis engine status.
+   * Returns the status of the LLM-based analysis system (Claude via AWS Bedrock).
+   * @returns any AI analysis engine status returned.
+   * @throws ApiError
+   */
+  static getModelStatus() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/predictions/model-status",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+};
+
+// services/RatingsService.ts
+var RatingsService = class {
+  /**
+   * Historical rating snapshots for an app.
+   * @param appUuid
+   * @param limit
+   * @param cursor
+   * @param order
+   * @param platform
+   * @param startDate
+   * @param endDate
+   * @returns any Rating history returned.
+   * @throws ApiError
+   */
+  static getRatingsHistory(appUuid, limit, cursor, order, platform, startDate, endDate) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/ratings/history",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor,
+        "order": order,
+        "platform": platform,
+        "start_date": startDate,
+        "end_date": endDate
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Latest rating snapshot for an app.
+   * @param appUuid
+   * @param platform
+   * @returns RatingSummary Rating summary returned.
+   * @throws ApiError
+   */
+  static getRatingsSummary(appUuid, platform) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/ratings/summary",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "platform": platform
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Compare app ratings against competitors.
+   * @param appUuid
+   * @param platform
+   * @returns RatingsComparison Comparison returned.
+   * @throws ApiError
+   */
+  static getRatingsComparison(appUuid, platform) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/ratings/comparison",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "platform": platform
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+};
+
+// services/ReplyTemplatesService.ts
+var ReplyTemplatesService = class {
+  /**
+   * List system and custom reply templates.
+   * @returns any Templates returned.
+   * @throws ApiError
+   */
+  static getReplyTemplates() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reply-templates",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Create a custom reply template.
+   * @param requestBody
+   * @returns ReplyTemplate Template created.
+   * @throws ApiError
+   */
+  static postReplyTemplate(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/reply-templates",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Replace a reply template.
+   * @param templateId
+   * @param requestBody
+   * @returns ReplyTemplate Template updated.
+   * @throws ApiError
+   */
+  static putReplyTemplate(templateId, requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/api/v1/reply-templates/{templateId}",
+      path: {
+        "templateId": templateId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Patch fields on a reply template.
+   * @param templateId
+   * @param requestBody
+   * @returns ReplyTemplate Template updated.
+   * @throws ApiError
+   */
+  static patchReplyTemplate(templateId, requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/api/v1/reply-templates/{templateId}",
+      path: {
+        "templateId": templateId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Remove a custom reply template.
+   * @param templateId
+   * @returns void
+   * @throws ApiError
+   */
+  static deleteReplyTemplate(templateId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/v1/reply-templates/{templateId}",
+      path: {
+        "templateId": templateId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * List reply template performance metrics.
+   * @param days
+   * @param templateId
+   * @returns any Template analytics returned.
+   * @throws ApiError
+   */
+  static getTemplatePerformance(days = 90, templateId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reply-templates/performance",
+      query: {
+        "days": days,
+        "template_id": templateId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Alias for template performance listing.
+   * @returns any Template analytics returned.
+   * @throws ApiError
+   */
+  static getTemplateComparison() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reply-templates/comparison",
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+};
+
+// services/ReviewsService.ts
+var ReviewsService = class {
+  /**
+   * Paginated reviews for an app.
+   * @param appUuid
+   * @param limit
+   * @param cursor
+   * @param sentiment
+   * @param platform
+   * @returns any Reviews returned.
+   * @throws ApiError
+   */
+  static getAppReviews(appUuid, limit, cursor, sentiment, platform) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/reviews",
+      path: {
+        "appUuid": appUuid
+      },
+      query: {
+        "limit": limit,
+        "cursor": cursor,
+        "sentiment": sentiment,
+        "platform": platform
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Retrieve stored reply metadata for a review.
+   * @param appUuid
+   * @param reviewId
+   * @returns ReviewReplyStatus Reply status returned.
+   * @throws ApiError
+   */
+  static getReviewReply(appUuid, reviewId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/reviews/{reviewId}/reply",
+      path: {
+        "appUuid": appUuid,
+        "reviewId": reviewId
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Generate an AI-generated reply draft for a review.
+   * @param appUuid
+   * @param reviewId
+   * @param requestBody
+   * @returns ReviewReplyDraft Draft generated.
+   * @throws ApiError
+   */
+  static postGenerateReviewReply(appUuid, reviewId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/{appUuid}/reviews/{reviewId}/reply/generate",
+      path: {
+        "appUuid": appUuid,
+        "reviewId": reviewId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Publish a reply back to the originating store.
+   * @param appUuid
+   * @param reviewId
+   * @param requestBody
+   * @returns ReviewReplyStatus Reply posted.
+   * @throws ApiError
+   */
+  static postReviewReply(appUuid, reviewId, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/apps/{appUuid}/reviews/{reviewId}/reply/post",
+      path: {
+        "appUuid": appUuid,
+        "reviewId": reviewId
+      },
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Aggregate reply performance metrics for an app.
+   * @param appUuid
+   * @returns ReplyAnalytics Reply analytics returned.
+   * @throws ApiError
+   */
+  static getReplyAnalytics(appUuid) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{appUuid}/replies/analytics",
+      path: {
+        "appUuid": appUuid
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`,
+        404: `Resource not found.`
+      }
+    });
+  }
+  /**
+   * Discover reviews across all connected apps.
+   * @param limit
+   * @param cursor
+   * @param appUuid
+   * @param sentiment
+   * @returns any Reviews returned.
+   * @throws ApiError
+   */
+  static getTenantReviews(limit, cursor, appUuid, sentiment) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reviews",
+      query: {
+        "limit": limit,
+        "cursor": cursor,
+        "app_uuid": appUuid,
+        "sentiment": sentiment
+      },
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Retrieve reviews tied to a specific segment.
+   * @param appUuid App UUID assigned by Tritonium.
+   * @param segmentType
+   * @returns any Reviews returned.
+   * @throws ApiError
+   */
+  static getSegmentReviews(appUuid, segmentType) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{app_uuid}/segments/{segment_type}/reviews",
+      path: {
+        "app_uuid": appUuid,
+        "segment_type": segmentType
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * List reviews with viral engagement.
+   * @param appUuid App UUID assigned by Tritonium.
+   * @param lookbackHours
+   * @param minEngagement
+   * @param sentiment
+   * @returns any Viral review payload.
+   * @throws ApiError
+   */
+  static getViralReviews(appUuid, lookbackHours = 48, minEngagement = 50, sentiment) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/apps/{app_uuid}/reviews/viral",
+      path: {
+        "app_uuid": appUuid
+      },
+      query: {
+        "lookback_hours": lookbackHours,
+        "min_engagement": minEngagement,
+        "sentiment": sentiment
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+  /**
+   * Retrieve engagement history for a review.
+   * @param reviewId
+   * @param appUuid
+   * @returns any History returned.
+   * @throws ApiError
+   */
+  static getReviewEngagementHistory(reviewId, appUuid) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/reviews/{review_id}/engagement/history",
+      path: {
+        "review_id": reviewId
+      },
+      query: {
+        "app_uuid": appUuid
+      },
+      errors: {
+        401: `Authentication required or token invalid.`,
+        403: `Request not permitted for this user.`
+      }
+    });
+  }
+};
+
+// services/UsersService.ts
+var UsersService = class {
+  /**
+   * Retrieve the authenticated user's profile.
+   * @returns UserSummary Profile details.
+   * @throws ApiError
+   */
+  static getMe() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/v1/me",
+      errors: {
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Update profile attributes for the active user.
+   * @param requestBody
+   * @returns UserSummary Profile updated.
+   * @throws ApiError
+   */
+  static patchProfile(requestBody) {
+    return request(OpenAPI, {
+      method: "PATCH",
+      url: "/api/v1/profile",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`
+      }
+    });
+  }
+  /**
+   * Mark onboarding tour completion for the signed-in user.
+   * @param requestBody
+   * @returns any User updated.
+   * @throws ApiError
+   */
+  static postUserOnboardingState(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/v1/users/me/onboarding",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+  /**
+   * Replace profile attributes for the active user.
+   * @param requestBody
+   * @returns UserSummary Profile updated.
+   * @throws ApiError
+   */
+  static putProfile(requestBody) {
+    return request(OpenAPI, {
+      method: "PUT",
+      url: "/api/v1/users/me/onboarding",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Request validation failed.`,
+        401: `Authentication required or token invalid.`
+      }
+    });
+  }
+};
+
+exports.AlertsService = AlertsService;
+exports.ApiError = ApiError;
+exports.AppsService = AppsService;
+exports.AuthService = AuthService;
+exports.BillingService = BillingService;
+exports.CancelError = CancelError;
+exports.CancelablePromise = CancelablePromise;
+exports.CredentialsService = CredentialsService;
+exports.EventTypes = EventTypes;
+exports.HealthService = HealthService;
+exports.InsightsService = InsightsService;
+exports.IntegrationsService = IntegrationsService;
+exports.InternalService = InternalService;
+exports.OpenAPI = OpenAPI;
+exports.PredictionsService = PredictionsService;
+exports.RatingsService = RatingsService;
+exports.ReplyTemplatesService = ReplyTemplatesService;
+exports.ReviewsService = ReviewsService;
+exports.UsersService = UsersService;
+exports.WebhookExpiredError = WebhookExpiredError;
+exports.WebhookSignatureError = WebhookSignatureError;
+exports.WebhookVerificationError = WebhookVerificationError;
+exports.clearAuth = clearAuth;
+exports.configure = configure;
+exports.configureApiKey = configureApiKey;
+exports.configureBearerToken = configureBearerToken;
+exports.constructEvent = constructEvent;
+exports.getConfiguration = getConfiguration;
+exports.isWebhookError = isWebhookError;
+exports.verifySignature = verifySignature;
+exports.verifyTimestamp = verifyTimestamp;
+exports.verifyWebhook = verifyWebhook;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map