@lpextend/node-sdk 1.1.2

package/dist/index.js

@@ -0,0 +1,2162 @@
+'use strict';
+
+// src/types/index.ts
+var LPExtendSDKError = class extends Error {
+  constructor(message, code, status, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "LPExtendSDKError";
+  }
+};
+var ErrorCodes = {
+  /** Not running inside shell iframe */
+  NOT_IN_SHELL: "NOT_IN_SHELL",
+  /** SDK initialization failed */
+  INIT_FAILED: "INIT_FAILED",
+  /** App not registered or disabled */
+  APP_NOT_REGISTERED: "APP_NOT_REGISTERED",
+  /** Authentication failed */
+  UNAUTHORIZED: "UNAUTHORIZED",
+  /** Scope not granted - update app registration */
+  SCOPE_DENIED: "SCOPE_DENIED",
+  /** Resource not found */
+  NOT_FOUND: "NOT_FOUND",
+  /** API call failed */
+  API_ERROR: "API_ERROR",
+  /** Request timeout */
+  TIMEOUT: "TIMEOUT",
+  /** Invalid configuration */
+  INVALID_CONFIG: "INVALID_CONFIG",
+  /** Revision conflict - resource was modified */
+  REVISION_CONFLICT: "REVISION_CONFLICT",
+  /** Rate limit exceeded */
+  RATE_LIMITED: "RATE_LIMITED"
+};
+
+// src/domains.ts
+var ZONE_MAP = {
+  va: "z1",
+  // US
+  lo: "z2",
+  // EU
+  sy: "z3"
+  // AU/APAC
+};
+var GEO_MAP = {
+  z1: "p-us",
+  z2: "p-eu",
+  z3: "p-au"
+};
+var domainCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+var DomainResolver = class {
+  constructor(accountId) {
+    this.region = null;
+    this.zone = null;
+    this.geo = null;
+    this.accountId = accountId;
+  }
+  /**
+   * Get domain for a specific LP service
+   */
+  async getDomain(service) {
+    const domains = await this.getDomains();
+    const domain = domains.find((d) => d.service === service);
+    return domain?.baseURI || null;
+  }
+  /**
+   * Get all domains for the account
+   */
+  async getDomains() {
+    const cached = domainCache.get(this.accountId);
+    if (cached && cached.expires > Date.now()) {
+      return cached.domains;
+    }
+    const response = await fetch(
+      `https://api.liveperson.net/api/account/${this.accountId}/service/baseURI.json?version=1.0`,
+      {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch domains: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const domains = data.baseURIs || [];
+    const asyncMessagingEnt = domains.find((d) => d.service === "asyncMessagingEnt");
+    if (asyncMessagingEnt) {
+      this.region = asyncMessagingEnt.baseURI.split(".")[0];
+      this.zone = ZONE_MAP[this.region] || null;
+      this.geo = this.zone ? GEO_MAP[this.zone] : null;
+      if (this.zone && this.region && this.geo) {
+        const additionalDomains = this.getAdditionalDomains();
+        for (const additional of additionalDomains) {
+          if (!domains.find((d) => d.service === additional.service)) {
+            domains.push(additional);
+          }
+        }
+      }
+    }
+    domainCache.set(this.accountId, {
+      domains,
+      expires: Date.now() + CACHE_TTL_MS
+    });
+    return domains;
+  }
+  /**
+   * Get additional domains not in CSDS
+   */
+  getAdditionalDomains() {
+    if (!this.zone || !this.region || !this.geo) {
+      return [];
+    }
+    return [
+      {
+        account: this.accountId,
+        service: "aiStudioPlatformService",
+        baseURI: `aistudio-${this.geo}.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "proactive",
+        baseURI: `proactive-messaging.${this.zone}.fs.liveperson.com`
+      },
+      {
+        account: this.accountId,
+        service: "botlogs",
+        baseURI: `${this.region}.bc-bot.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "bot",
+        baseURI: `${this.region}.bc-bot.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "botPlatform",
+        baseURI: `${this.region}.bc-platform.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "kb",
+        baseURI: `${this.region}.bc-kb.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "context",
+        baseURI: `${this.region}.context.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "recommendation",
+        baseURI: `${this.zone}.askmaven.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "proactiveHandoff",
+        baseURI: `${this.region}.handoff.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "convBuild",
+        baseURI: `${this.region}.bc-sso.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "bcmgmt",
+        baseURI: `${this.region}.bc-mgmt.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "bcintg",
+        baseURI: `${this.region}.bc-intg.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "bcnlu",
+        baseURI: `${this.region}.bc-nlu.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "promptlibrary",
+        baseURI: `${this.geo}.promptlibrary.liveperson.net`
+      }
+    ];
+  }
+  /**
+   * Clear cached domains for this account
+   */
+  clearCache() {
+    domainCache.delete(this.accountId);
+  }
+};
+
+// src/http.ts
+var SCOPE_CONFIG = {
+  // Account Configuration APIs (Bearer auth)
+  skills: { service: "accountConfigReadOnly", pathPrefix: "/le-users/skills", urlPattern: "accountConfig" },
+  users: { service: "accountConfigReadOnly", pathPrefix: "/le-users/users", urlPattern: "accountConfig" },
+  agentGroups: { service: "accountConfigReadOnly", pathPrefix: "/le-users/agentGroups", urlPattern: "accountConfig" },
+  profiles: { service: "accountConfigReadOnly", pathPrefix: "/le-users/profiles", urlPattern: "accountConfig" },
+  lobs: { service: "accountConfigReadOnly", pathPrefix: "/le-users/lobs", urlPattern: "accountConfig" },
+  predefinedContent: { service: "accountConfigReadOnly", pathPrefix: "/le-predefined-content/predefinedContent", urlPattern: "accountConfig" },
+  automaticMessages: { service: "accountConfigReadOnly", pathPrefix: "/le-campaigns/automatic-messages", urlPattern: "accountConfig" },
+  workingHours: { service: "accountConfigReadOnly", pathPrefix: "/le-users/working-hours", urlPattern: "accountConfig" },
+  specialOccasions: { service: "accountConfigReadOnly", pathPrefix: "/le-users/special-occasions", urlPattern: "accountConfig" },
+  campaigns: { service: "accountConfigReadOnly", pathPrefix: "/le-campaigns/campaigns", urlPattern: "accountConfig" },
+  engagements: { service: "accountConfigReadOnly", pathPrefix: "/le-campaigns/campaigns", urlPattern: "accountConfig" },
+  // AI Studio APIs (CC-Bearer auth)
+  aiStudio: { service: "aiStudioPlatformService", pathPrefix: "", authType: "cc-bearer", urlPattern: "aiStudio" },
+  promptLibrary: { service: "aiStudioPlatformService", pathPrefix: "", authType: "cc-bearer", urlPattern: "aiStudio" },
+  // Messaging APIs
+  messagingHistory: { service: "msgHist", pathPrefix: "/messaging_history/api/account", urlPattern: "messaging" },
+  messagingOperations: { service: "asyncMessagingEnt", pathPrefix: "/api/account", urlPattern: "messaging" },
+  connectToMessaging: { service: "asyncMessagingEnt", pathPrefix: "/api/account", urlPattern: "messaging" },
+  agentMetrics: { service: "leDataReporting", pathPrefix: "/operations/api/account", urlPattern: "messaging" },
+  agentActivity: { service: "leDataReporting", pathPrefix: "/operations/api/account", urlPattern: "messaging" },
+  outboundReporting: { service: "leDataReporting", pathPrefix: "/operations/api/account", urlPattern: "messaging" },
+  // Other LP APIs
+  conversationOrchestrator: { service: "maven", pathPrefix: "/v1/account", urlPattern: "messaging" },
+  faas: { service: "faasUI", pathPrefix: "/api/account", urlPattern: "messaging" },
+  proactiveMessaging: { service: "proactive", pathPrefix: "/api", urlPattern: "custom" },
+  // LP Prompt Library (separate from AI Studio Prompt Library)
+  prompts: { service: "promptlibrary", pathPrefix: "/v2", urlPattern: "prompts" }
+};
+var WRITE_SERVICE = "accountConfigReadWrite";
+var HTTPClient = class {
+  constructor(accountId, accessToken, defaultTimeout, debug) {
+    this.accountId = accountId;
+    this.accessToken = accessToken;
+    this.defaultTimeout = defaultTimeout;
+    this.debug = debug;
+    this.domainResolver = new DomainResolver(accountId);
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path, body, options) {
+    return this.request("POST", path, { ...options, body });
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(path, body, options) {
+    return this.request("PUT", path, { ...options, body });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request("PATCH", path, { ...options, body });
+  }
+  /**
+   * Create a scoped client for a specific API domain
+   * This allows setting default options like authMode for all requests
+   */
+  withDefaults(defaults) {
+    return new ScopedHTTPClient(this, defaults);
+  }
+  /**
+   * Build the full URL for an LP API endpoint
+   */
+  async buildUrl(path, scopeConfig, isWrite) {
+    const serviceName = isWrite && scopeConfig.service.startsWith("accountConfig") ? WRITE_SERVICE : scopeConfig.service;
+    const domain = await this.domainResolver.getDomain(serviceName);
+    if (!domain) {
+      throw new LPExtendSDKError(
+        `Could not resolve domain for service: ${serviceName}`,
+        ErrorCodes.API_ERROR
+      );
+    }
+    let url;
+    switch (scopeConfig.urlPattern) {
+      case "accountConfig":
+        url = `https://${domain}/api/account/${this.accountId}/configuration${scopeConfig.pathPrefix}`;
+        break;
+      case "messaging":
+        url = `https://${domain}${scopeConfig.pathPrefix}/${this.accountId}`;
+        break;
+      case "aiStudio":
+        url = `https://${domain}/api/v2`;
+        break;
+      case "prompts":
+        url = `https://${domain}${scopeConfig.pathPrefix}`;
+        if (path.startsWith("/system")) {
+          url += `/system/prompts${path.substring("/system".length)}`;
+          return url;
+        } else if (path.startsWith("/account")) {
+          url += `/accounts/${this.accountId}/prompts${path.substring("/account".length)}`;
+          return url;
+        } else if (path.startsWith("/llm-providers")) {
+          url += `/accounts/${this.accountId}/configurations/llm-providers${path.substring("/llm-providers".length)}`;
+          return url;
+        }
+        break;
+      case "custom":
+      default:
+        url = `https://${domain}${scopeConfig.pathPrefix}`;
+        break;
+    }
+    if (path) {
+      url += path.startsWith("/") ? path : `/${path}`;
+    }
+    return url;
+  }
+  /**
+   * Determine scope from path
+   */
+  getScopeFromPath(path) {
+    const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
+    const firstSegment = normalizedPath.split("/")[0];
+    if (firstSegment === "prompts") {
+      return "prompts";
+    }
+    if (firstSegment === "ai-studio" || normalizedPath.startsWith("ai-studio")) {
+      return "aiStudio";
+    }
+    if (firstSegment === "messaging") {
+      const secondSegment = normalizedPath.split("/")[1];
+      if (secondSegment === "history") return "messagingHistory";
+      if (secondSegment === "agent-metrics") return "agentMetrics";
+      if (secondSegment === "agent-activity") return "agentActivity";
+      if (secondSegment === "operations") return "messagingOperations";
+      if (secondSegment === "connect") return "connectToMessaging";
+      if (secondSegment === "outbound") return "outboundReporting";
+      return "messagingHistory";
+    }
+    const scopeMap = {
+      skills: "skills",
+      users: "users",
+      "agent-groups": "agentGroups",
+      profiles: "profiles",
+      lobs: "lobs",
+      campaigns: "campaigns",
+      engagements: "engagements",
+      "predefined-content": "predefinedContent",
+      "automatic-messages": "automaticMessages",
+      "working-hours": "workingHours",
+      "special-occasions": "specialOccasions"
+    };
+    return scopeMap[firstSegment] || firstSegment;
+  }
+  /**
+   * Make HTTP request to LP API
+   */
+  async request(method, path, options) {
+    const scope = this.getScopeFromPath(path);
+    const scopeConfig = SCOPE_CONFIG[scope];
+    if (!scopeConfig) {
+      throw new LPExtendSDKError(
+        `Unknown scope: ${scope}. Path: ${path}`,
+        ErrorCodes.SCOPE_DENIED
+      );
+    }
+    const isWrite = method !== "GET";
+    const pathWithoutScope = this.stripScopeFromPath(path, scope);
+    const url = await this.buildUrl(pathWithoutScope, scopeConfig, isWrite);
+    let fullUrl = url;
+    if (options?.params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(options.params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      });
+      const paramString = searchParams.toString();
+      if (paramString) {
+        fullUrl += (fullUrl.includes("?") ? "&" : "?") + paramString;
+      }
+    }
+    const authMode = options?.authMode || scopeConfig.authType || "bearer";
+    const authHeader = authMode === "cc-bearer" ? `CC-Bearer ${this.accessToken}` : `Bearer ${this.accessToken}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: authHeader,
+      ...options?.headers
+    };
+    if (options?.revision) {
+      headers["If-Match"] = options.revision;
+    }
+    this.log(`${method} ${fullUrl}`, { scope, authMode });
+    const timeout = options?.timeout || this.defaultTimeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(fullUrl, {
+        method,
+        headers,
+        body: options?.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleError(response);
+      }
+      const contentType = response.headers.get("content-type");
+      const hasJsonBody = contentType?.includes("application/json");
+      let responseData;
+      if (hasJsonBody && response.status !== 204) {
+        responseData = await response.json();
+      }
+      const revision = response.headers.get("ac-revision") || response.headers.get("etag") || response.headers.get("x-revision") || void 0;
+      return {
+        data: responseData,
+        revision: revision || void 0
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new LPExtendSDKError("Request timeout", ErrorCodes.TIMEOUT);
+      }
+      if (error instanceof LPExtendSDKError) {
+        throw error;
+      }
+      throw new LPExtendSDKError(error.message, ErrorCodes.API_ERROR);
+    }
+  }
+  /**
+   * Strip the scope prefix from the path
+   */
+  stripScopeFromPath(path, scope) {
+    const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
+    const prefixMap = {
+      skills: ["skills"],
+      users: ["users"],
+      agentGroups: ["agent-groups"],
+      profiles: ["profiles"],
+      lobs: ["lobs"],
+      campaigns: ["campaigns"],
+      engagements: ["engagements"],
+      predefinedContent: ["predefined-content"],
+      automaticMessages: ["automatic-messages"],
+      workingHours: ["working-hours"],
+      specialOccasions: ["special-occasions"],
+      aiStudio: ["ai-studio"],
+      messagingHistory: ["messaging/history"],
+      agentMetrics: ["messaging/agent-metrics"],
+      agentActivity: ["messaging/agent-activity"],
+      messagingOperations: ["messaging/operations"],
+      connectToMessaging: ["messaging/connect"],
+      outboundReporting: ["messaging/outbound"],
+      prompts: ["prompts"]
+    };
+    const prefixes = prefixMap[scope] || [];
+    for (const prefix of prefixes) {
+      if (normalizedPath.startsWith(prefix)) {
+        const remaining = normalizedPath.substring(prefix.length);
+        return remaining.startsWith("/") ? remaining : `/${remaining}`;
+      }
+    }
+    return path;
+  }
+  /**
+   * Handle HTTP error responses
+   */
+  async handleError(response) {
+    const errorBody = await response.json().catch(() => ({ message: "Unknown error" }));
+    switch (response.status) {
+      case 401:
+        throw new LPExtendSDKError(
+          "Authentication failed",
+          ErrorCodes.UNAUTHORIZED,
+          response.status,
+          errorBody
+        );
+      case 403:
+        throw new LPExtendSDKError(
+          errorBody.message || "Access denied",
+          ErrorCodes.SCOPE_DENIED,
+          response.status,
+          errorBody
+        );
+      case 404:
+        throw new LPExtendSDKError(
+          errorBody.message || "Resource not found",
+          ErrorCodes.NOT_FOUND,
+          response.status,
+          errorBody
+        );
+      case 409:
+        throw new LPExtendSDKError(
+          errorBody.message || "Revision conflict - resource was modified",
+          ErrorCodes.REVISION_CONFLICT,
+          response.status,
+          errorBody
+        );
+      case 429:
+        throw new LPExtendSDKError(
+          errorBody.message || "Rate limit exceeded",
+          ErrorCodes.RATE_LIMITED,
+          response.status,
+          errorBody
+        );
+      default:
+        throw new LPExtendSDKError(
+          `API Error: ${response.status} - ${errorBody.message || response.statusText}`,
+          ErrorCodes.API_ERROR,
+          response.status,
+          errorBody
+        );
+    }
+  }
+  /**
+   * Debug logging
+   */
+  log(...args) {
+    if (this.debug) {
+      console.log("[LP-Extend-SDK]", ...args);
+    }
+  }
+};
+var ScopedHTTPClient = class {
+  constructor(client, defaults) {
+    this.client = client;
+    this.defaults = defaults;
+  }
+  async get(path, options) {
+    return this.client.get(path, this.mergeOptions(options));
+  }
+  async post(path, body, options) {
+    return this.client.post(path, body, this.mergeOptions(options));
+  }
+  async put(path, body, options) {
+    return this.client.put(path, body, this.mergeOptions(options));
+  }
+  async delete(path, options) {
+    return this.client.delete(path, this.mergeOptions(options));
+  }
+  async patch(path, body, options) {
+    return this.client.patch(path, body, this.mergeOptions(options));
+  }
+  mergeOptions(options) {
+    return {
+      ...this.defaults,
+      ...options,
+      headers: {
+        ...this.defaults.headers,
+        ...options?.headers
+      }
+    };
+  }
+};
+
+// src/api/account-config.api.ts
+var SkillsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all skills
+   */
+  async getAll() {
+    return this.http.get("/skills");
+  }
+  /**
+   * Get a skill by ID
+   */
+  async getById(skillId) {
+    return this.http.get(`/skills/${skillId}`);
+  }
+  /**
+   * Create a new skill
+   */
+  async create(skill) {
+    return this.http.post("/skills", skill);
+  }
+  /**
+   * Update a skill
+   * @param skillId - The skill ID
+   * @param skill - Updated skill data
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(skillId, skill, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/skills/${skillId}`, skill, { revision: rev });
+  }
+  /**
+   * Delete a skill
+   * @param skillId - The skill ID
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(skillId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/skills/${skillId}`, { revision: rev });
+  }
+};
+var UsersAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all users
+   */
+  async getAll() {
+    return this.http.get("/users");
+  }
+  /**
+   * Get a user by ID
+   */
+  async getById(userId) {
+    return this.http.get(`/users/${userId}`);
+  }
+  /**
+   * Create a new user
+   */
+  async create(user) {
+    return this.http.post("/users", user);
+  }
+  /**
+   * Update a user
+   * @param userId - The user ID
+   * @param user - Updated user data
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(userId, user, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/users/${userId}`, user, { revision: rev });
+  }
+  /**
+   * Delete a user
+   * @param userId - The user ID
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(userId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/users/${userId}`, { revision: rev });
+  }
+  /**
+   * Get the current authenticated user
+   */
+  async getSelf() {
+    return this.http.get("/users/self");
+  }
+};
+var AgentGroupsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all agent groups
+   */
+  async getAll() {
+    return this.http.get("/agent-groups");
+  }
+  /**
+   * Get an agent group by ID
+   */
+  async getById(groupId) {
+    return this.http.get(`/agent-groups/${groupId}`);
+  }
+  /**
+   * Create a new agent group
+   */
+  async create(group) {
+    return this.http.post("/agent-groups", group);
+  }
+  /**
+   * Update an agent group
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(groupId, group, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/agent-groups/${groupId}`, group, { revision: rev });
+  }
+  /**
+   * Delete an agent group
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(groupId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/agent-groups/${groupId}`, { revision: rev });
+  }
+};
+var ProfilesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all profiles
+   */
+  async getAll() {
+    return this.http.get("/profiles");
+  }
+  /**
+   * Get a profile by ID
+   */
+  async getById(profileId) {
+    return this.http.get(`/profiles/${profileId}`);
+  }
+  /**
+   * Create a new profile
+   */
+  async create(profile) {
+    return this.http.post("/profiles", profile);
+  }
+  /**
+   * Update a profile
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(profileId, profile, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/profiles/${profileId}`, profile, { revision: rev });
+  }
+  /**
+   * Delete a profile
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(profileId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/profiles/${profileId}`, { revision: rev });
+  }
+};
+var LOBsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all LOBs
+   */
+  async getAll() {
+    return this.http.get("/lobs");
+  }
+  /**
+   * Get a LOB by ID
+   */
+  async getById(lobId) {
+    return this.http.get(`/lobs/${lobId}`);
+  }
+  /**
+   * Create a new LOB
+   */
+  async create(lob) {
+    return this.http.post("/lobs", lob);
+  }
+  /**
+   * Update a LOB
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(lobId, lob, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/lobs/${lobId}`, lob, { revision: rev });
+  }
+  /**
+   * Delete a LOB
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(lobId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/lobs/${lobId}`, { revision: rev });
+  }
+};
+var CampaignsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all campaigns
+   */
+  async getAll() {
+    return this.http.get("/campaigns");
+  }
+  /**
+   * Get a campaign by ID
+   */
+  async getById(campaignId) {
+    return this.http.get(`/campaigns/${campaignId}`);
+  }
+  /**
+   * Create a new campaign
+   */
+  async create(campaign) {
+    return this.http.post("/campaigns", campaign);
+  }
+  /**
+   * Update a campaign
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(campaignId, campaign, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/campaigns/${campaignId}`, campaign, { revision: rev });
+  }
+  /**
+   * Delete a campaign
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(campaignId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/campaigns/${campaignId}`, { revision: rev });
+  }
+};
+var EngagementsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all engagements for a campaign
+   */
+  async getByCampaign(campaignId) {
+    return this.http.get(`/campaigns/${campaignId}/engagements`);
+  }
+  /**
+   * Get an engagement by ID
+   */
+  async getById(campaignId, engagementId) {
+    return this.http.get(`/campaigns/${campaignId}/engagements/${engagementId}`);
+  }
+  /**
+   * Create a new engagement
+   */
+  async create(engagement) {
+    return this.http.post(`/campaigns/${engagement.campaignId}/engagements`, engagement);
+  }
+  /**
+   * Update an engagement
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(campaignId, engagementId, engagement, revision) {
+    const rev = revision || (await this.getByCampaign(campaignId)).revision;
+    return this.http.put(`/campaigns/${campaignId}/engagements/${engagementId}`, engagement, { revision: rev });
+  }
+  /**
+   * Delete an engagement
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(campaignId, engagementId, revision) {
+    const rev = revision || (await this.getByCampaign(campaignId)).revision;
+    return this.http.delete(`/campaigns/${campaignId}/engagements/${engagementId}`, { revision: rev });
+  }
+};
+var PredefinedContentAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all predefined content
+   */
+  async getAll() {
+    return this.http.get("/predefined-content");
+  }
+  /**
+   * Get predefined content by ID
+   */
+  async getById(contentId) {
+    return this.http.get(`/predefined-content/${contentId}`);
+  }
+  /**
+   * Create new predefined content
+   */
+  async create(content) {
+    return this.http.post("/predefined-content", content);
+  }
+  /**
+   * Update predefined content
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(contentId, content, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/predefined-content/${contentId}`, content, { revision: rev });
+  }
+  /**
+   * Delete predefined content
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(contentId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/predefined-content/${contentId}`, { revision: rev });
+  }
+};
+var AutomaticMessagesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all automatic messages
+   */
+  async getAll() {
+    return this.http.get("/automatic-messages");
+  }
+  /**
+   * Get an automatic message by ID
+   */
+  async getById(messageId) {
+    return this.http.get(`/automatic-messages/${messageId}`);
+  }
+  /**
+   * Create a new automatic message
+   */
+  async create(message) {
+    return this.http.post("/automatic-messages", message);
+  }
+  /**
+   * Update an automatic message
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(messageId, message, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/automatic-messages/${messageId}`, message, { revision: rev });
+  }
+  /**
+   * Delete an automatic message
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(messageId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/automatic-messages/${messageId}`, { revision: rev });
+  }
+};
+var WorkingHoursAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all working hours schedules
+   */
+  async getAll() {
+    return this.http.get("/working-hours");
+  }
+  /**
+   * Get working hours by ID
+   */
+  async getById(scheduleId) {
+    return this.http.get(`/working-hours/${scheduleId}`);
+  }
+  /**
+   * Create new working hours schedule
+   */
+  async create(schedule) {
+    return this.http.post("/working-hours", schedule);
+  }
+  /**
+   * Update working hours schedule
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(scheduleId, schedule, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/working-hours/${scheduleId}`, schedule, { revision: rev });
+  }
+  /**
+   * Delete working hours schedule
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(scheduleId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/working-hours/${scheduleId}`, { revision: rev });
+  }
+};
+var SpecialOccasionsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all special occasions
+   */
+  async getAll() {
+    return this.http.get("/special-occasions");
+  }
+  /**
+   * Get a special occasion by ID
+   */
+  async getById(occasionId) {
+    return this.http.get(`/special-occasions/${occasionId}`);
+  }
+  /**
+   * Create a new special occasion
+   */
+  async create(occasion) {
+    return this.http.post("/special-occasions", occasion);
+  }
+  /**
+   * Update a special occasion
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async update(occasionId, occasion, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.put(`/special-occasions/${occasionId}`, occasion, { revision: rev });
+  }
+  /**
+   * Delete a special occasion
+   * @param revision - Optional revision for optimistic locking (auto-fetched if not provided)
+   */
+  async delete(occasionId, revision) {
+    const rev = revision || (await this.getAll()).revision;
+    return this.http.delete(`/special-occasions/${occasionId}`, { revision: rev });
+  }
+};
+
+// src/api/ai-studio.api.ts
+var CategoriesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getAll() {
+    return this.http.get("/ai-studio/categories");
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/categories", data);
+  }
+  async update(categoryId, data) {
+    return this.http.put(`/ai-studio/categories/${categoryId}`, data);
+  }
+  async delete(categoryId) {
+    return this.http.delete(`/ai-studio/categories/${categoryId}`);
+  }
+};
+var ConversationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getAll(params) {
+    return this.http.get("/ai-studio/conversations", { params });
+  }
+  async getById(convId) {
+    return this.http.get(`/ai-studio/conversations/${convId}`);
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/conversations", data);
+  }
+  async update(convId, data) {
+    return this.http.put(`/ai-studio/conversations/${convId}`, data);
+  }
+  async delete(convId) {
+    return this.http.delete(`/ai-studio/conversations/${convId}`);
+  }
+  async updateAttributes(convId, data) {
+    return this.http.put(`/ai-studio/conversations/${convId}/attributes`, data);
+  }
+  async close(convId) {
+    return this.http.patch(`/ai-studio/conversations/${convId}/close`);
+  }
+  async export(params) {
+    return this.http.get("/ai-studio/conversations/export", { params });
+  }
+  async upload(conversations) {
+    return this.http.post("/ai-studio/conversations/upload", { conversations });
+  }
+};
+var SummaryAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/summary", data);
+  }
+  async createBatch(data) {
+    return this.http.post("/ai-studio/summary/batch", data);
+  }
+  async getBatch(offset, limit) {
+    return this.http.get("/ai-studio/summary/batch", { params: { offset, limit } });
+  }
+  async getBatchById(summaryId) {
+    return this.http.get(`/ai-studio/summary/batch/${summaryId}`);
+  }
+  async deleteBatch(summaryId) {
+    return this.http.delete(`/ai-studio/summary/batch/${summaryId}`);
+  }
+};
+var QueryAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async generate(data) {
+    return this.http.post("/ai-studio/query", data);
+  }
+};
+var SimulationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getAll(params) {
+    return this.http.get("/ai-studio/simulations", { params });
+  }
+  async getById(simulationId) {
+    return this.http.get(`/ai-studio/simulations/${simulationId}`);
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/simulations", data);
+  }
+  async update(simulationId, data) {
+    return this.http.put(`/ai-studio/simulations/${simulationId}`, data);
+  }
+  async delete(simulationId) {
+    return this.http.delete(`/ai-studio/simulations/${simulationId}`);
+  }
+  async getStatus(simulationId) {
+    return this.http.get(`/ai-studio/simulations/${simulationId}/status`);
+  }
+  async getJobResults(simulationId, jobId) {
+    return this.http.get(`/ai-studio/simulations/${simulationId}/jobs/${jobId}`);
+  }
+  async cancel(simulationId) {
+    return this.http.post(`/ai-studio/simulations/${simulationId}/cancel`);
+  }
+};
+var TranscriptAnalysisAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getAll(owner, limit, startAfterId) {
+    return this.http.get("/ai-studio/transcript-analysis", {
+      params: { owner, limit, start_after_id: startAfterId }
+    });
+  }
+  async getById(analysisId, excludeConversations, excludeQuestions) {
+    return this.http.get(`/ai-studio/transcript-analysis/${analysisId}`, {
+      params: { exclude_conversations: excludeConversations, exclude_questions: excludeQuestions }
+    });
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/transcript-analysis", data);
+  }
+  async update(analysisId, data) {
+    return this.http.put(`/ai-studio/transcript-analysis/${analysisId}`, data);
+  }
+  async delete(analysisId) {
+    return this.http.delete(`/ai-studio/transcript-analysis/${analysisId}`);
+  }
+};
+var KnowledgebasesAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getAll() {
+    return this.http.get("/ai-studio/knowledgebases");
+  }
+  async getKai() {
+    return this.http.get("/ai-studio/knowledgebases/kai");
+  }
+  async getById(kbId) {
+    return this.http.get(`/ai-studio/knowledgebases/${kbId}`);
+  }
+  async delete(kbId) {
+    return this.http.delete(`/ai-studio/knowledgebases/${kbId}`);
+  }
+  async getHealth(kbId) {
+    return this.http.get(`/ai-studio/knowledgebases/${kbId}/health`);
+  }
+  async refresh(kbId) {
+    return this.http.get(`/ai-studio/knowledgebases/${kbId}/refresh`);
+  }
+  async search(kbId, data) {
+    return this.http.post(`/ai-studio/knowledgebases/${kbId}/search`, data);
+  }
+  async getItems(kbId) {
+    return this.http.get(`/ai-studio/knowledgebases/${kbId}/items`);
+  }
+  async getItemsBySource(kbId, sourceId) {
+    return this.http.get(`/ai-studio/knowledgebases/${kbId}/items/${sourceId}`);
+  }
+  async createItems(kbId, sourceId, items) {
+    return this.http.post(`/ai-studio/knowledgebases/${kbId}/items/${sourceId}`, items);
+  }
+  async updateItems(kbId, sourceId, items) {
+    return this.http.put(`/ai-studio/knowledgebases/${kbId}/items/${sourceId}`, items);
+  }
+  async deleteItems(kbId, sourceId, itemIds) {
+    return this.http.delete(`/ai-studio/knowledgebases/${kbId}/items/${sourceId}`, { body: itemIds });
+  }
+};
+var EvaluatorsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async similarity(evaluationType, data) {
+    return this.http.post("/ai-studio/evaluators/similarity", data, {
+      params: { type: evaluationType }
+    });
+  }
+  async resolution(data) {
+    return this.http.post("/ai-studio/evaluators/resolution", data);
+  }
+  async guidedRouting(data) {
+    return this.http.post("/ai-studio/evaluators/guided-routing", data);
+  }
+};
+var GeneratorsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async qaFromModel(modelId) {
+    return this.http.get(`/ai-studio/generators/qa/model/${modelId}`);
+  }
+  async qaFromKnowledgebase(kbIds, generateAnswers, useRandomSections) {
+    return this.http.get("/ai-studio/generators/qa/knowledgebase", {
+      params: { kb_id: kbIds.join(","), generate_answers: generateAnswers, use_random_sections: useRandomSections }
+    });
+  }
+  async qaFromConversationCloud(data) {
+    return this.http.post("/ai-studio/generators/qa/conversation-cloud", data);
+  }
+  async kaiRoutesLlm(data) {
+    return this.http.post("/ai-studio/generators/routes/kai-llm", data);
+  }
+  async kaiRoutes(data) {
+    return this.http.post("/ai-studio/generators/routes/kai", data);
+  }
+  async kaiRoutesStatus(flowId) {
+    return this.http.get("/ai-studio/generators/routes/kai/status", {
+      params: { flow_id: flowId }
+    });
+  }
+};
+var PromptLibraryAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getAll() {
+    return this.http.get("/ai-studio/prompt-library");
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/prompt-library", data);
+  }
+  async update(promptId, data) {
+    return this.http.put(`/ai-studio/prompt-library/${promptId}`, data);
+  }
+  async getProviders() {
+    return this.http.get("/ai-studio/prompt-library/providers");
+  }
+  async getSystemPrompts() {
+    return this.http.get("/ai-studio/prompt-library/system");
+  }
+};
+var AIStudioUsersAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getSelf() {
+    return this.http.get("/ai-studio/users/self");
+  }
+  async getAll() {
+    return this.http.get("/ai-studio/users");
+  }
+  async getDetails() {
+    return this.http.get("/ai-studio/users/details");
+  }
+  async create(data) {
+    return this.http.post("/ai-studio/users", data);
+  }
+  async update(userId, data) {
+    return this.http.put(`/ai-studio/users/${userId}`, data);
+  }
+  async delete(userId) {
+    return this.http.delete(`/ai-studio/users/${userId}`);
+  }
+  async updateModels(userId, data) {
+    return this.http.put(`/ai-studio/users/${userId}/models`, data);
+  }
+  async agreeToTerms(userId) {
+    return this.http.get(`/ai-studio/users/${userId}/terms`);
+  }
+};
+var FlowsAPI = class {
+  constructor(http, accountId) {
+    this.http = http;
+    this.accountId = accountId;
+  }
+  /**
+   * List all flows for the account
+   * GET /api/v2/flows?account_id={accountId}
+   */
+  async getAll() {
+    return this.http.get("/ai-studio/flows", {
+      params: { account_id: this.accountId }
+    });
+  }
+  /**
+   * Get a specific flow by ID
+   * GET /api/v2/flows/{flowId}
+   */
+  async getById(flowId) {
+    return this.http.get(`/ai-studio/flows/${flowId}`);
+  }
+  /**
+   * Invoke a flow
+   * POST /api/v2/flows/{flowId}
+   */
+  async invoke(flowId, data) {
+    return this.http.post(`/ai-studio/flows/${flowId}`, data);
+  }
+  /**
+   * Invoke a promptless flow (quick response)
+   * POST /api/v2/flows/response
+   */
+  async invokeWithResponse(prompt, messages, text) {
+    const body = { prompt };
+    if (messages) body.messages = messages;
+    if (text) body.text = text;
+    return this.http.post("/ai-studio/flows/response", body);
+  }
+};
+var AIStudioAPI = class {
+  constructor(http, accountId) {
+    const scopedHttp = http.withDefaults({ authMode: "cc-bearer" });
+    this.categories = new CategoriesAPI(scopedHttp);
+    this.conversations = new ConversationsAPI(scopedHttp);
+    this.summary = new SummaryAPI(scopedHttp);
+    this.query = new QueryAPI(scopedHttp);
+    this.simulations = new SimulationsAPI(scopedHttp);
+    this.transcriptAnalysis = new TranscriptAnalysisAPI(scopedHttp);
+    this.knowledgebases = new KnowledgebasesAPI(scopedHttp);
+    this.evaluators = new EvaluatorsAPI(scopedHttp);
+    this.generators = new GeneratorsAPI(scopedHttp);
+    this.promptLibrary = new PromptLibraryAPI(scopedHttp);
+    this.users = new AIStudioUsersAPI(scopedHttp);
+    this.flows = new FlowsAPI(scopedHttp, accountId);
+  }
+};
+
+// src/api/messaging.api.ts
+var MessagingHistoryAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Query messaging conversations
+   */
+  async query(params) {
+    return this.http.post("/messaging/history", params);
+  }
+  /**
+   * Get a single conversation by ID
+   */
+  async getConversation(conversationId) {
+    return this.http.get(`/messaging/history/${conversationId}`);
+  }
+  /**
+   * Get conversations by IDs (batch)
+   */
+  async getConversations(conversationIds) {
+    return this.http.post("/messaging/history/batch", { conversationIds });
+  }
+  /**
+   * Export conversations matching criteria
+   */
+  async export(params) {
+    return this.http.post("/messaging/history/export", params);
+  }
+};
+var AgentMetricsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get current metrics for agents
+   */
+  async getMetrics(params) {
+    return this.http.post("/messaging/agent-metrics", params || {});
+  }
+  /**
+   * Get metrics for a specific agent
+   */
+  async getAgentMetrics(agentId) {
+    return this.http.get(`/messaging/agent-metrics/${agentId}`);
+  }
+  /**
+   * Get metrics summary by skill
+   */
+  async getBySkill(skillId) {
+    return this.http.get(`/messaging/agent-metrics/skill/${skillId}`);
+  }
+  /**
+   * Get metrics summary by agent group
+   */
+  async getByAgentGroup(groupId) {
+    return this.http.get(`/messaging/agent-metrics/group/${groupId}`);
+  }
+};
+var AgentActivityAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Query agent activity
+   */
+  async query(params) {
+    return this.http.post("/messaging/agent-activity", params);
+  }
+  /**
+   * Get activity for a specific agent
+   */
+  async getAgentActivity(agentId, from, to) {
+    return this.http.get(`/messaging/agent-activity/${agentId}`, {
+      params: { from, to }
+    });
+  }
+};
+var MessagingOperationsAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Transfer a conversation to another skill or agent
+   */
+  async transfer(request) {
+    return this.http.post(`/messaging/operations/${request.conversationId}/transfer`, {
+      targetSkillId: request.targetSkillId,
+      targetAgentId: request.targetAgentId,
+      reason: request.reason
+    });
+  }
+  /**
+   * Close a conversation
+   */
+  async close(request) {
+    return this.http.post(`/messaging/operations/${request.conversationId}/close`, {
+      closeReason: request.closeReason
+    });
+  }
+  /**
+   * Send a message to a conversation
+   */
+  async sendMessage(request) {
+    return this.http.post(`/messaging/operations/${request.conversationId}/message`, {
+      message: request.message,
+      contentType: request.contentType,
+      richContent: request.richContent
+    });
+  }
+  /**
+   * Set conversation priority
+   */
+  async setPriority(conversationId, priority) {
+    return this.http.post(`/messaging/operations/${conversationId}/priority`, { priority });
+  }
+  /**
+   * Set conversation TTR (Time To Respond)
+   */
+  async setTTR(conversationId, ttrType, value) {
+    return this.http.post(`/messaging/operations/${conversationId}/ttr`, { ttrType, value });
+  }
+};
+var ConnectToMessagingAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new conversation
+   */
+  async createConversation(request) {
+    return this.http.post("/messaging/connect", request);
+  }
+  /**
+   * Get available campaigns and engagements for creating conversations
+   */
+  async getAvailableEngagements() {
+    return this.http.get("/messaging/connect/engagements");
+  }
+};
+var OutboundReportingAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Query outbound campaign reports
+   */
+  async query(params) {
+    return this.http.post("/messaging/outbound/reports", params);
+  }
+  /**
+   * Get report for a specific campaign
+   */
+  async getCampaignReport(campaignId, from, to) {
+    return this.http.get(`/messaging/outbound/reports/${campaignId}`, {
+      params: { from, to }
+    });
+  }
+  /**
+   * Get aggregate outbound stats
+   */
+  async getAggregateStats(from, to) {
+    return this.http.get("/messaging/outbound/reports/aggregate", {
+      params: { from, to }
+    });
+  }
+};
+var MessagingAPI = class {
+  constructor(http) {
+    this.history = new MessagingHistoryAPI(http);
+    this.agentMetrics = new AgentMetricsAPI(http);
+    this.agentActivity = new AgentActivityAPI(http);
+    this.operations = new MessagingOperationsAPI(http);
+    this.connect = new ConnectToMessagingAPI(http);
+    this.outbound = new OutboundReportingAPI(http);
+  }
+};
+
+// src/api/sentinel.api.ts
+var SentinelAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get login URL for OAuth redirect
+   *
+   * Returns a URL to redirect the user to for LivePerson authentication.
+   * After successful auth, user is redirected back with an authorization code.
+   *
+   * @returns Login URL for OAuth redirect
+   *
+   * @example
+   * ```typescript
+   * const { url } = await sdk.sentinel.getLoginUrl();
+   * // Redirect user to LP login
+   * window.location.href = url;
+   * ```
+   */
+  async getLoginUrl() {
+    const response = await this.http.get("/idp/login-url");
+    return response.data;
+  }
+  /**
+   * Exchange OAuth authorization code for access token
+   *
+   * After the user completes LP authentication and is redirected back,
+   * use this method to exchange the authorization code for tokens.
+   *
+   * @param request - Token exchange request with code and redirect URI
+   * @returns Token object with access token, refresh token, and user info
+   *
+   * @example
+   * ```typescript
+   * // Get code from URL params after redirect
+   * const urlParams = new URLSearchParams(window.location.search);
+   * const code = urlParams.get('code');
+   *
+   * const token = await sdk.sentinel.exchangeToken({
+   *   code,
+   *   redirect: window.location.origin + '/callback',
+   *   appname: 'my-app',
+   * });
+   *
+   * // Store token for API calls
+   * localStorage.setItem('lpToken', token.accessToken);
+   * ```
+   */
+  async exchangeToken(request) {
+    const response = await this.http.post("/idp/token", request);
+    return response.data;
+  }
+  /**
+   * Logout and revoke token
+   *
+   * Revokes the current access token, ending the user's session.
+   *
+   * @example
+   * ```typescript
+   * await sdk.sentinel.logout();
+   * // Clear local storage and redirect to login
+   * localStorage.removeItem('lpToken');
+   * window.location.href = '/login';
+   * ```
+   */
+  async logout() {
+    await this.http.post("/idp/logout", {});
+  }
+  /**
+   * Get LivePerson domains for the account
+   *
+   * Returns the domain URLs for various LP services.
+   * Useful for making direct API calls to specific LP services.
+   *
+   * @returns Map of service names to domain URLs
+   *
+   * @example
+   * ```typescript
+   * const domains = await sdk.sentinel.getDomains();
+   * console.log('Sentinel domain:', domains.sentinel);
+   * console.log('Account Config domain:', domains.accountConfigReadOnly);
+   * ```
+   */
+  async getDomains() {
+    const response = await this.http.get("/idp/domains");
+    return response.data;
+  }
+  /**
+   * Authenticate with Conversation Builder
+   *
+   * Exchanges the LP access token for a CB-specific token.
+   * Required for making Conversation Builder API calls.
+   *
+   * @returns CB authentication info with token and organization ID
+   *
+   * @example
+   * ```typescript
+   * const cbAuth = await sdk.sentinel.authenticateCB();
+   * if (cbAuth.success) {
+   *   const cbToken = cbAuth.successResult.apiAccessToken;
+   *   const cbOrg = cbAuth.successResult.sessionOrganizationId;
+   *   // Use cbToken for CB API calls
+   * }
+   * ```
+   */
+  async authenticateCB() {
+    const response = await this.http.get("/idp/authenticate-cb");
+    return response.data;
+  }
+};
+
+// src/api/prompts.api.ts
+var LPPromptsAPI = class {
+  constructor(http) {
+    this.scopedHttp = http.withDefaults({
+      params: { source: "ccui" }
+    });
+  }
+  /**
+   * Get all system prompts (read-only, provided by LivePerson)
+   */
+  async getSystemPrompts(params) {
+    const response = await this.scopedHttp.get(
+      "/prompts/system",
+      { params }
+    );
+    const prompts = response.data?.successResult?.prompts || [];
+    return {
+      data: prompts,
+      revision: response.revision
+    };
+  }
+  /**
+   * Get all account prompts
+   */
+  async getAccountPrompts(params) {
+    const response = await this.scopedHttp.get(
+      "/prompts/account",
+      { params }
+    );
+    const prompts = response.data?.successResult?.prompts || [];
+    return {
+      data: prompts,
+      revision: response.revision
+    };
+  }
+  /**
+   * Get a single account prompt by ID
+   */
+  async getById(promptId) {
+    return this.scopedHttp.get(`/prompts/account/${promptId}`);
+  }
+  /**
+   * Create a new account prompt
+   */
+  async create(prompt) {
+    return this.scopedHttp.post("/prompts/account", prompt);
+  }
+  /**
+   * Update an account prompt
+   * @param promptId - The prompt ID
+   * @param prompt - Updated prompt data
+   */
+  async update(promptId, prompt) {
+    return this.scopedHttp.put(`/prompts/account/${promptId}`, prompt);
+  }
+  /**
+   * Delete an account prompt
+   * @param promptId - The prompt ID
+   */
+  async delete(promptId) {
+    return this.scopedHttp.delete(`/prompts/account/${promptId}`);
+  }
+  /**
+   * Get LLM provider subscriptions for the account
+   */
+  async getLLMProviders() {
+    const response = await this.scopedHttp.get(
+      "/prompts/llm-providers"
+    );
+    const providers = response.data?.successResult?.provider_subscriptions || [];
+    return {
+      data: providers,
+      revision: response.revision
+    };
+  }
+};
+
+// src/sdk.ts
+var LPExtendSDK = class {
+  /**
+   * Create SDK instance (use initializeSDK() instead for async init)
+   */
+  constructor(config, initResult) {
+    this.config = config;
+    this.debug = config.debug ?? false;
+    this.grantedScopes = initResult.grantedScopes;
+    this.appName = initResult.appName;
+    const timeout = config.timeout ?? 3e4;
+    this.http = new HTTPClient(
+      config.accountId,
+      config.accessToken,
+      timeout,
+      this.debug
+    );
+    this.skills = new SkillsAPI(this.http);
+    this.users = new UsersAPI(this.http);
+    this.agentGroups = new AgentGroupsAPI(this.http);
+    this.profiles = new ProfilesAPI(this.http);
+    this.lobs = new LOBsAPI(this.http);
+    this.campaigns = new CampaignsAPI(this.http);
+    this.engagements = new EngagementsAPI(this.http);
+    this.predefinedContent = new PredefinedContentAPI(this.http);
+    this.automaticMessages = new AutomaticMessagesAPI(this.http);
+    this.workingHours = new WorkingHoursAPI(this.http);
+    this.specialOccasions = new SpecialOccasionsAPI(this.http);
+    this.aiStudio = new AIStudioAPI(this.http, this.config.accountId);
+    this.messaging = new MessagingAPI(this.http);
+    this.sentinel = new SentinelAPI(this.http);
+    this.prompts = new LPPromptsAPI(this.http);
+    this.log("SDK initialized with scopes:", this.grantedScopes);
+  }
+  /**
+   * Get the current account ID
+   */
+  get accountId() {
+    return this.config.accountId;
+  }
+  /**
+   * Get the app ID
+   */
+  get appId() {
+    return this.config.appId;
+  }
+  /**
+   * Check if a scope was granted
+   */
+  hasScope(scope) {
+    return this.grantedScopes.includes(scope);
+  }
+  /**
+   * Check if multiple scopes were granted
+   */
+  hasScopes(scopes) {
+    return scopes.every((scope) => this.grantedScopes.includes(scope));
+  }
+  /**
+   * Check if any of the specified scopes were granted
+   */
+  hasAnyScope(scopes) {
+    return scopes.some((scope) => this.grantedScopes.includes(scope));
+  }
+  /**
+   * Debug logging
+   */
+  log(...args) {
+    if (this.debug) {
+      console.log("[LP-Extend-SDK]", ...args);
+    }
+  }
+};
+async function createSDK(config) {
+  if (!config.appId) {
+    throw new LPExtendSDKError("appId is required", ErrorCodes.INVALID_CONFIG);
+  }
+  if (!config.accountId) {
+    throw new LPExtendSDKError("accountId is required", ErrorCodes.INVALID_CONFIG);
+  }
+  if (!config.accessToken && !config.extendToken && !config.shellToken) {
+    throw new LPExtendSDKError(
+      "Either accessToken, extendToken, or shellToken is required",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  const debug = config.debug ?? false;
+  const timeout = config.timeout ?? 3e4;
+  let shellBaseUrl = config.shellBaseUrl;
+  if (!shellBaseUrl) {
+    if (typeof window !== "undefined") {
+      try {
+        if (window.self !== window.top && document.referrer) {
+          const url = new URL(document.referrer);
+          shellBaseUrl = url.origin;
+        }
+      } catch {
+      }
+      shellBaseUrl = shellBaseUrl || window.location.origin;
+    } else {
+      throw new LPExtendSDKError(
+        "shellBaseUrl is required in non-browser environments",
+        ErrorCodes.INVALID_CONFIG
+      );
+    }
+  }
+  let accessToken = config.accessToken;
+  if (!accessToken && config.extendToken) {
+    if (debug) {
+      console.log("[LP-Extend-SDK] Verifying ExtendJWT with shell");
+    }
+    const verifyUrl = `${shellBaseUrl}/api/v2/auth/verify-child`;
+    const extendController = new AbortController();
+    const extendTimeoutId = setTimeout(() => extendController.abort(), timeout);
+    try {
+      const verifyResponse = await fetch(verifyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          extendToken: config.extendToken,
+          appId: config.appId
+        }),
+        signal: extendController.signal
+      });
+      clearTimeout(extendTimeoutId);
+      if (!verifyResponse.ok) {
+        const errorData = await verifyResponse.json().catch(() => ({}));
+        if (verifyResponse.status === 401) {
+          throw new LPExtendSDKError(
+            errorData.message || "ExtendJWT invalid or expired",
+            ErrorCodes.UNAUTHORIZED,
+            verifyResponse.status,
+            errorData
+          );
+        }
+        throw new LPExtendSDKError(
+          errorData.message || `ExtendJWT verification failed: ${verifyResponse.status}`,
+          ErrorCodes.API_ERROR,
+          verifyResponse.status,
+          errorData
+        );
+      }
+      const authData = await verifyResponse.json();
+      accessToken = authData.lpAccessToken;
+      if (debug) {
+        console.log("[LP-Extend-SDK] ExtendJWT verified, got LP access token");
+        console.log("[LP-Extend-SDK] User:", authData.lpUserId, "Account:", authData.lpAccountId);
+      }
+    } catch (error) {
+      clearTimeout(extendTimeoutId);
+      if (error instanceof LPExtendSDKError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new LPExtendSDKError("ExtendJWT verification timeout", ErrorCodes.TIMEOUT);
+      }
+      throw new LPExtendSDKError(
+        `ExtendJWT verification failed: ${error.message}`,
+        ErrorCodes.INIT_FAILED
+      );
+    }
+  }
+  if (!accessToken && config.shellToken) {
+    if (debug) {
+      console.log("[LP-Extend-SDK] Fetching LP token from shell using shellToken (legacy)");
+    }
+    const tokenUrl = `${shellBaseUrl}/api/v1/shell/token/${config.accountId}/lp-token`;
+    const tokenController = new AbortController();
+    const tokenTimeoutId = setTimeout(() => tokenController.abort(), timeout);
+    try {
+      const tokenResponse = await fetch(tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Shell-Token": config.shellToken
+        },
+        body: JSON.stringify({
+          appId: config.appId,
+          scopes: config.scopes
+        }),
+        signal: tokenController.signal
+      });
+      clearTimeout(tokenTimeoutId);
+      if (!tokenResponse.ok) {
+        const errorData = await tokenResponse.json().catch(() => ({}));
+        if (tokenResponse.status === 401) {
+          throw new LPExtendSDKError(
+            errorData.message || "Shell token invalid or expired",
+            ErrorCodes.UNAUTHORIZED,
+            tokenResponse.status,
+            errorData
+          );
+        }
+        if (tokenResponse.status === 403) {
+          throw new LPExtendSDKError(
+            errorData.message || "App not installed or disabled",
+            ErrorCodes.APP_NOT_REGISTERED,
+            tokenResponse.status,
+            errorData
+          );
+        }
+        if (tokenResponse.status === 404) {
+          throw new LPExtendSDKError(
+            errorData.message || "No LP token found - user may need to re-authenticate",
+            ErrorCodes.NOT_FOUND,
+            tokenResponse.status,
+            errorData
+          );
+        }
+        throw new LPExtendSDKError(
+          errorData.message || `Failed to retrieve LP token: ${tokenResponse.status}`,
+          ErrorCodes.API_ERROR,
+          tokenResponse.status,
+          errorData
+        );
+      }
+      const tokenData = await tokenResponse.json();
+      accessToken = tokenData.accessToken;
+      if (debug) {
+        console.log("[LP-Extend-SDK] LP token retrieved successfully");
+      }
+    } catch (error) {
+      clearTimeout(tokenTimeoutId);
+      if (error instanceof LPExtendSDKError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new LPExtendSDKError("LP token retrieval timeout", ErrorCodes.TIMEOUT);
+      }
+      throw new LPExtendSDKError(
+        `Failed to retrieve LP token: ${error.message}`,
+        ErrorCodes.INIT_FAILED
+      );
+    }
+  }
+  if (debug) {
+    console.log("[LP-Extend-SDK] Verifying scopes with shell:", shellBaseUrl);
+  }
+  const initUrl = `${shellBaseUrl}/api/v1/lp/${config.accountId}/sdk/init`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(initUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "X-App-Id": config.appId
+      },
+      body: JSON.stringify({ scopes: config.scopes || [] }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({ message: "Unknown error" }));
+      if (response.status === 404) {
+        throw new LPExtendSDKError(
+          `App "${config.appId}" is not registered for account ${config.accountId}`,
+          ErrorCodes.APP_NOT_REGISTERED,
+          response.status,
+          errorBody
+        );
+      }
+      if (response.status === 403) {
+        throw new LPExtendSDKError(
+          errorBody.message || "App is disabled or not authorized",
+          ErrorCodes.APP_NOT_REGISTERED,
+          response.status,
+          errorBody
+        );
+      }
+      if (response.status === 401) {
+        throw new LPExtendSDKError(
+          "Authentication failed - invalid access token",
+          ErrorCodes.UNAUTHORIZED,
+          response.status,
+          errorBody
+        );
+      }
+      throw new LPExtendSDKError(
+        `SDK initialization failed: ${errorBody.message || response.statusText}`,
+        ErrorCodes.INIT_FAILED,
+        response.status,
+        errorBody
+      );
+    }
+    const initResult = await response.json();
+    if (debug) {
+      console.log("[LP-Extend-SDK] Scopes verified:", initResult.grantedScopes);
+      console.log("[LP-Extend-SDK] SDK will call LP APIs directly");
+    }
+    const resolvedConfig = { ...config, accessToken };
+    return new LPExtendSDK(resolvedConfig, initResult);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error.name === "AbortError") {
+      throw new LPExtendSDKError("SDK initialization timeout", ErrorCodes.TIMEOUT);
+    }
+    if (error instanceof LPExtendSDKError) {
+      throw error;
+    }
+    throw new LPExtendSDKError(
+      `SDK initialization failed: ${error.message}`,
+      ErrorCodes.INIT_FAILED
+    );
+  }
+}
+
+// src/index.ts
+async function initializeSDK(config) {
+  return createSDK(config);
+}
+var VERSION = "1.0.0";
+var Scopes = {
+  // Account Configuration
+  SKILLS: "skills",
+  USERS: "users",
+  AGENT_GROUPS: "agentGroups",
+  PROFILES: "profiles",
+  LOBS: "lobs",
+  PREDEFINED_CONTENT: "predefinedContent",
+  AUTOMATIC_MESSAGES: "automaticMessages",
+  WORKING_HOURS: "workingHours",
+  SPECIAL_OCCASIONS: "specialOccasions",
+  CAMPAIGNS: "campaigns",
+  ENGAGEMENTS: "engagements",
+  // Messaging & Conversations
+  MESSAGING_HISTORY: "messagingHistory",
+  MESSAGING_OPERATIONS: "messagingOperations",
+  CONNECT_TO_MESSAGING: "connectToMessaging",
+  // Agent & Reporting
+  AGENT_METRICS: "agentMetrics",
+  AGENT_ACTIVITY: "agentActivity",
+  OUTBOUND_REPORTING: "outboundReporting",
+  // AI & Automation
+  AI_STUDIO: "aiStudio",
+  CONVERSATION_BUILDER: "conversationBuilder",
+  CONVERSATION_ORCHESTRATOR: "conversationOrchestrator",
+  /** AI Studio Prompt Library (different from LP Prompts) */
+  PROMPT_LIBRARY: "promptLibrary",
+  /** LP Prompts API (Prompt Library) */
+  LP_PROMPTS: "prompts",
+  FAAS: "faas",
+  // Proactive
+  PROACTIVE_MESSAGING: "proactiveMessaging"
+};
+async function getShellToken(config) {
+  const { shellBaseUrl, accountId, shellToken, appId, scopes, timeout = 1e4 } = config;
+  if (!shellBaseUrl) {
+    throw new LPExtendSDKError("shellBaseUrl is required", ErrorCodes.INVALID_CONFIG);
+  }
+  if (!accountId) {
+    throw new LPExtendSDKError("accountId is required", ErrorCodes.INVALID_CONFIG);
+  }
+  if (!shellToken) {
+    throw new LPExtendSDKError("shellToken is required", ErrorCodes.INVALID_CONFIG);
+  }
+  if (!appId) {
+    throw new LPExtendSDKError("appId is required", ErrorCodes.INVALID_CONFIG);
+  }
+  const url = `${shellBaseUrl.replace(/\/$/, "")}/api/v1/shell/token/${accountId}/lp-token`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Shell-Token": shellToken
+      },
+      body: JSON.stringify({
+        appId,
+        scopes
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      if (response.status === 401) {
+        throw new LPExtendSDKError(
+          errorData.message || "Shell token invalid or expired",
+          ErrorCodes.UNAUTHORIZED,
+          response.status,
+          errorData
+        );
+      }
+      if (response.status === 403) {
+        throw new LPExtendSDKError(
+          errorData.message || "App not installed or disabled",
+          ErrorCodes.APP_NOT_REGISTERED,
+          response.status,
+          errorData
+        );
+      }
+      if (response.status === 404) {
+        throw new LPExtendSDKError(
+          errorData.message || "No LP token found for user",
+          ErrorCodes.NOT_FOUND,
+          response.status,
+          errorData
+        );
+      }
+      throw new LPExtendSDKError(
+        errorData.message || `Shell token request failed: ${response.status}`,
+        ErrorCodes.API_ERROR,
+        response.status,
+        errorData
+      );
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof LPExtendSDKError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new LPExtendSDKError("Shell token request timed out", ErrorCodes.TIMEOUT);
+    }
+    throw new LPExtendSDKError(
+      `Failed to retrieve shell token: ${error instanceof Error ? error.message : "Unknown error"}`,
+      ErrorCodes.API_ERROR
+    );
+  }
+}
+
+exports.AIStudioAPI = AIStudioAPI;
+exports.AIStudioUsersAPI = AIStudioUsersAPI;
+exports.AgentActivityAPI = AgentActivityAPI;
+exports.AgentGroupsAPI = AgentGroupsAPI;
+exports.AgentMetricsAPI = AgentMetricsAPI;
+exports.AutomaticMessagesAPI = AutomaticMessagesAPI;
+exports.CampaignsAPI = CampaignsAPI;
+exports.CategoriesAPI = CategoriesAPI;
+exports.ConnectToMessagingAPI = ConnectToMessagingAPI;
+exports.ConversationsAPI = ConversationsAPI;
+exports.EngagementsAPI = EngagementsAPI;
+exports.ErrorCodes = ErrorCodes;
+exports.EvaluatorsAPI = EvaluatorsAPI;
+exports.FlowsAPI = FlowsAPI;
+exports.GeneratorsAPI = GeneratorsAPI;
+exports.KnowledgebasesAPI = KnowledgebasesAPI;
+exports.LOBsAPI = LOBsAPI;
+exports.LPExtendSDK = LPExtendSDK;
+exports.LPExtendSDKError = LPExtendSDKError;
+exports.LPPromptsAPI = LPPromptsAPI;
+exports.MessagingAPI = MessagingAPI;
+exports.MessagingHistoryAPI = MessagingHistoryAPI;
+exports.MessagingOperationsAPI = MessagingOperationsAPI;
+exports.OutboundReportingAPI = OutboundReportingAPI;
+exports.PredefinedContentAPI = PredefinedContentAPI;
+exports.ProfilesAPI = ProfilesAPI;
+exports.PromptLibraryAPI = PromptLibraryAPI;
+exports.QueryAPI = QueryAPI;
+exports.Scopes = Scopes;
+exports.SentinelAPI = SentinelAPI;
+exports.SimulationsAPI = SimulationsAPI;
+exports.SkillsAPI = SkillsAPI;
+exports.SpecialOccasionsAPI = SpecialOccasionsAPI;
+exports.SummaryAPI = SummaryAPI;
+exports.TranscriptAnalysisAPI = TranscriptAnalysisAPI;
+exports.UsersAPI = UsersAPI;
+exports.VERSION = VERSION;
+exports.WorkingHoursAPI = WorkingHoursAPI;
+exports.createSDK = createSDK;
+exports.getShellToken = getShellToken;
+exports.initializeSDK = initializeSDK;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map