@uipath/integrationservice-sdk 1.197.0 → 1.198.0-preview.80

package/dist/index.js

@@ -19811,7 +19811,7 @@ class TextApiResponse2 {
 var package_default = {
   name: "@uipath/integrationservice-sdk",
   license: "MIT",
-  version: "1.197.0",
+  version: "1.198.0-preview.80",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -39985,6 +39985,10 @@ var getAuthContext = async (options = {}) => {
     tenantName
   };
 };
+
+// ../auth/src/index.ts
+init_constants();
+
 // ../auth/src/interactive.ts
 init_src();
 
@@ -40009,6 +40013,20 @@ var API_DOMAIN_MAP = new Map([
   [SessionsApi, "connections"],
   [ElementsApi, "elements"]
 ]);
+function baseApiClassName(name) {
+  let end = name.length;
+  while (end > 0 && name[end - 1] >= "0" && name[end - 1] <= "9") {
+    end--;
+  }
+  return name.slice(0, end);
+}
+var API_DOMAIN_BY_NAME = new Map([...API_DOMAIN_MAP].map(([ApiClass, domain]) => [
+  baseApiClassName(ApiClass.name),
+  domain
+]));
+function resolveApiDomain(ApiClass) {
+  return API_DOMAIN_MAP.get(ApiClass) ?? API_DOMAIN_BY_NAME.get(baseApiClassName(ApiClass.name));
+}
 async function getValidatedAuthContext(options) {
   const ctx = await getAuthContext({
     tenant: options?.tenant,
@@ -40045,7 +40063,7 @@ async function createElementsConfig(options) {
   });
 }
 async function createApiClient(ApiClass, options) {
-  const domain = API_DOMAIN_MAP.get(ApiClass);
+  const domain = resolveApiDomain(ApiClass);
   if (!domain) {
     throw new Error(`Unknown API class: ${ApiClass.name}`);
   }
@@ -40217,6 +40235,246 @@ function folderOverride(folderKey) {
     }
   });
 }
+var CONNECTORS_PATH_SEGMENT = "elements_/v3/element/connectors";
+var CONNECTOR_SOURCE_HEADER = "UiPath.CodingAgent";
+var CONNECTOR_BUILDER_SOURCE_HEADER = "UiPath.IntegrationService.ConnectorBuilder";
+var MAX_CONNECTOR_PAGES = 1000;
+function nextPageToken(response) {
+  const token = response.headers.get("elements-next-page-token") ?? response.headers.get("Elements-Next-Page-Token");
+  return token && token.trim().length > 0 ? token : undefined;
+}
+function connectorsUrl(ctx, suffix = "") {
+  return `${ctx.baseUrl}/${ctx.organizationId}/${ctx.tenantName}/${CONNECTORS_PATH_SEGMENT}${suffix}`;
+}
+async function failFromResponse(response, action) {
+  if (response.type === "opaqueredirect" || response.status === 0) {
+    throw new Error(`${action}: request was redirected (likely not authenticated or wrong tenant/host). Run \`uip login\` and retry.`);
+  }
+  const errorText = await response.text();
+  throw new Error(`${action}: ${response.status} ${response.statusText} - ${errorText}`);
+}
+var CONNECTOR_REQUEST_TIMEOUT_MS = 60000;
+async function connectorApiFetch(url, init) {
+  try {
+    return await fetch(url, {
+      ...init,
+      redirect: "manual",
+      signal: AbortSignal.timeout(CONNECTOR_REQUEST_TIMEOUT_MS)
+    });
+  } catch (e) {
+    if (e instanceof Error && e.name === "TimeoutError") {
+      throw new Error(`Request timed out after ${CONNECTOR_REQUEST_TIMEOUT_MS / 1000}s: ${url}. Check connectivity to the tenant and retry.`);
+    }
+    throw e;
+  }
+}
+async function importConnectorZip(options, zipBytes, fileName) {
+  const ctx = await getValidatedAuthContext(options);
+  const form = new FormData;
+  const part = zipBytes;
+  form.append("file", new Blob([part], { type: "application/zip" }), fileName);
+  const response = await connectorApiFetch(connectorsUrl(ctx, "/import"), {
+    method: "PUT",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      Accept: "application/json",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT),
+    body: form
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to import connector zip");
+  }
+  return await response.json();
+}
+async function createDesignConnector(options, connector) {
+  const ctx = await getValidatedAuthContext(options);
+  const response = await connectorApiFetch(connectorsUrl(ctx), {
+    method: "POST",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT),
+    body: JSON.stringify(connector)
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to create connector");
+  }
+  return await response.json();
+}
+async function updateDesignConnector(options, connectorId, connector) {
+  const ctx = await getValidatedAuthContext(options);
+  const response = await connectorApiFetch(connectorsUrl(ctx, `/${connectorId}`), {
+    method: "PUT",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT),
+    body: JSON.stringify(connector)
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to update connector");
+  }
+  return await response.json();
+}
+async function findDesignConnectorByKey(options, key) {
+  const ctx = await getValidatedAuthContext(options);
+  let nextPage;
+  let pages = 0;
+  do {
+    const params = new URLSearchParams({ pageSize: "200" });
+    if (nextPage) {
+      params.set("nextPage", nextPage);
+    }
+    const response = await connectorApiFetch(connectorsUrl(ctx, `?${params.toString()}`), {
+      method: "GET",
+      headers: addSdkUserAgentHeader({
+        Authorization: `Bearer ${ctx.accessToken}`,
+        Accept: "application/json",
+        "x-uipath-source": CONNECTOR_BUILDER_SOURCE_HEADER
+      }, SDK_USER_AGENT)
+    });
+    if (!response.ok) {
+      await failFromResponse(response, "Failed to list connectors");
+    }
+    const body = await response.json();
+    const page = Array.isArray(body) ? body : body.items ?? [];
+    const match = page.find((c) => c.key === key);
+    if (match) {
+      return { id: match.id, key: match.key, name: match.name };
+    }
+    if (page.length === 0) {
+      break;
+    }
+    nextPage = nextPageToken(response);
+    pages += 1;
+  } while (nextPage && pages < MAX_CONNECTOR_PAGES);
+  return null;
+}
+async function exportConnectorZip(options, connectorId) {
+  const ctx = await getValidatedAuthContext(options);
+  const response = await connectorApiFetch(connectorsUrl(ctx, `/${connectorId}/export?connectorType=REGULAR`), {
+    method: "GET",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      Accept: "application/octet-stream",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT)
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to export connector");
+  }
+  const buffer = await response.arrayBuffer();
+  return new Uint8Array(buffer);
+}
+var PUBLISH_PATH_SEGMENT = "elements_/v3/element/publish";
+function publishUrl(ctx, suffix = "") {
+  return `${ctx.baseUrl}/${ctx.organizationId}/${ctx.tenantName}/${PUBLISH_PATH_SEGMENT}${suffix}`;
+}
+async function publishConnector(options, args) {
+  const ctx = await getValidatedAuthContext(options);
+  const response = await connectorApiFetch(publishUrl(ctx, "/private"), {
+    method: "POST",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT),
+    body: JSON.stringify(args)
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to publish connector");
+  }
+  return await response.json();
+}
+async function getPublishStatus(options, publishId) {
+  const ctx = await getValidatedAuthContext(options);
+  const response = await connectorApiFetch(publishUrl(ctx, `/private/${encodeURIComponent(String(publishId))}/status`), {
+    method: "GET",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      Accept: "application/json",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT)
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to fetch publish status");
+  }
+  return await response.json();
+}
+async function getConnectorById(options, connectorId) {
+  const ctx = await getValidatedAuthContext(options);
+  const response = await connectorApiFetch(connectorsUrl(ctx, `/${connectorId}`), {
+    method: "GET",
+    headers: addSdkUserAgentHeader({
+      Authorization: `Bearer ${ctx.accessToken}`,
+      Accept: "application/json",
+      "x-uipath-source": CONNECTOR_SOURCE_HEADER
+    }, SDK_USER_AGENT)
+  });
+  if (!response.ok) {
+    await failFromResponse(response, "Failed to retrieve connector");
+  }
+  return await response.json();
+}
+async function listConnectors(options, params) {
+  const ctx = await getValidatedAuthContext(options);
+  const limit = params?.limit ?? 1000;
+  const sourceHeader = params?.design ? CONNECTOR_BUILDER_SOURCE_HEADER : CONNECTOR_SOURCE_HEADER;
+  const items = [];
+  let nextPage;
+  let truncated = false;
+  let pages = 0;
+  do {
+    const qs = new URLSearchParams({ pageSize: "200" });
+    if (nextPage) {
+      qs.set("nextPage", nextPage);
+    }
+    const response = await connectorApiFetch(connectorsUrl(ctx, `?${qs.toString()}`), {
+      method: "GET",
+      headers: addSdkUserAgentHeader({
+        Authorization: `Bearer ${ctx.accessToken}`,
+        Accept: "application/json",
+        "x-uipath-source": sourceHeader
+      }, SDK_USER_AGENT)
+    });
+    if (!response.ok) {
+      await failFromResponse(response, "Failed to list connectors");
+    }
+    const body = await response.json();
+    const page = Array.isArray(body) ? body : body.items ?? [];
+    for (const c of page) {
+      if (items.length >= limit) {
+        truncated = true;
+        break;
+      }
+      const id = c.id;
+      const key = c.key;
+      if (typeof id === "number" && typeof key === "string") {
+        items.push({
+          id,
+          key,
+          name: typeof c.name === "string" ? c.name : undefined,
+          description: typeof c.description === "string" ? c.description : undefined
+        });
+      }
+    }
+    if (truncated) {
+      break;
+    }
+    if (page.length === 0) {
+      break;
+    }
+    nextPage = nextPageToken(response);
+    pages += 1;
+  } while (nextPage && pages < MAX_CONNECTOR_PAGES);
+  return { items, truncated };
+}
 // src/dap/essential-config.ts
 var MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
 var MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
@@ -41460,6 +41718,33 @@ var DEFAULT_RULES = [
 function validateIntSvcNode(context, rules = DEFAULT_RULES) {
   return rules.flatMap((rule) => rule(context));
 }
+// src/pagination.ts
+var ELEMENTS_NEXT_PAGE_DONE = "DONE";
+var base64UrlDecode = (input) => {
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(base64, "base64").toString("utf8");
+  }
+  return atob(base64);
+};
+var decodeElementsNextPageToken = (token) => {
+  if (!token) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(base64UrlDecode(token));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var hasMoreElementsPages = (token) => {
+  const cursor = decodeElementsNextPageToken(token)?.providerNextPage;
+  return typeof cursor === "string" && cursor.length > 0 && cursor !== ELEMENTS_NEXT_PAGE_DONE;
+};
 export {
   validateRequiredParameters,
   validateRequiredFields,
@@ -41476,11 +41761,14 @@ export {
   validateEndpoint,
   validateConnectionId,
   validateConfiguration,
+  updateDesignConnector,
   toClrType,
   runInstanceDesignAction,
   querystring,
+  publishConnector,
   normalizeHttpMethod,
   mapValues,
+  listConnectors,
   instanceOfWebhookSpec,
   instanceOfValueOrBuilder,
   instanceOfUpdatePollingIntervalRequest,
@@ -41738,19 +42026,28 @@ export {
   instanceOfApiResultsAction,
   instanceOfAccessTokenResponse,
   inlineMultipartFileValues,
+  importConnectorZip,
+  hasMoreElementsPages,
   getWebhookConfig,
+  getValidatedAuthContext,
   getUuid,
+  getPublishStatus,
   getObjectMetadataAsSchema,
   getInstanceObjectMetadataAsSchema,
   getInstanceEventObjectMetadataAsSchema,
   getHttpRequestPreview,
   getEventOperationObjects,
   getEventObjectMetadataAsSchema,
+  getConnectorById,
   folderOverride,
+  findDesignConnectorByKey,
   extractMultipartParameters,
+  exportConnectorZip,
   exists,
   executeOperation,
+  decodeElementsNextPageToken,
   createElementsConfig,
+  createDesignConnector,
   createConnectionsConfig,
   createApiClient,
   canConsumeForm,
@@ -42786,6 +43083,7 @@ export {
   EditionDefaultFromJSONTyped,
   EditionDefaultFromJSON,
   EditionDefaultEditionEnum,
+  ELEMENTS_NEXT_PAGE_DONE,
   DictionaryWidgetDesignToJSONTyped,
   DictionaryWidgetDesignToJSON,
   DictionaryWidgetDesignOrBuilderToJSONTyped,
@@ -42923,4 +43221,4 @@ export {
   AccessTokenResponseFromJSON
 };
 
-//# debugId=12D99569551D807A64756E2164756E21
+//# debugId=E05B3E4BF9DA943064756E2164756E21

package/dist/src/client-factory.d.ts

@@ -11,6 +11,12 @@ export interface CreateApiClientOptions {
     tenant?: string;
     loginValidity?: number;
 }
+export declare function getValidatedAuthContext(options?: CreateApiClientOptions): Promise<{
+    baseUrl: string;
+    accessToken: string;
+    organizationId: string;
+    tenantName: string;
+}>;
 export declare function createConnectionsConfig(options?: CreateApiClientOptions): Promise<ConnectionsConfiguration>;
 export declare function createElementsConfig(options?: CreateApiClientOptions): Promise<ElementsConfiguration>;
 export declare function createApiClient<T>(ApiClass: new (config: ConnectionsConfiguration | ElementsConfiguration) => T, options?: CreateApiClientOptions): Promise<T>;
@@ -89,3 +95,172 @@ export interface EventOperationObject {
     supportedAuths?: string[];
 }
 export declare function folderOverride(folderKey?: string): InitOverrideFunction | undefined;
+/**
+ * Imported (parsed) connector returned by `PUT /connectors/import`.
+ * The server parses the zip into a Connector but does NOT persist it.
+ */
+export interface ImportedConnector {
+    key: string;
+    name?: string;
+    [k: string]: unknown;
+}
+/**
+ * Persisted connector returned by `POST /connectors` or `PUT /connectors/{id}`.
+ */
+export interface PersistedConnector extends ImportedConnector {
+    id: number;
+}
+/**
+ * Reference to an existing connector, returned by the lookup-by-key helper.
+ */
+export interface DesignConnectorRef {
+    id: number;
+    key: string;
+    name?: string;
+}
+/**
+ * Upload a connector zip for parsing/hydration.
+ *
+ * Endpoint: PUT {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors/import
+ *
+ * The server parses the zip, hydrates a `Connector` object, and returns it
+ * WITHOUT persisting it. The returned object carries the final connector key:
+ * the parser prefixes the key with `design` when it does not already contain
+ * that marker, so the key returned here matches the persisted key. Pass the
+ * returned object to `createDesignConnector` (new) or `updateDesignConnector`
+ * (existing) to persist it.
+ *
+ * The zip must contain a single top-level directory holding `app/element/element.json`.
+ */
+export declare function importConnectorZip(options: CreateApiClientOptions | undefined, zipBytes: Uint8Array, fileName: string): Promise<ImportedConnector>;
+/**
+ * Create a new connector. Pass the body returned by `importConnectorZip`.
+ *
+ * Endpoint: POST {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors
+ *
+ * The server rejects the request if a connector with the same key already
+ * exists; use `findDesignConnectorByKey` + `updateDesignConnector` to modify
+ * an existing connector.
+ */
+export declare function createDesignConnector(options: CreateApiClientOptions | undefined, connector: ImportedConnector): Promise<PersistedConnector>;
+/**
+ * Update an existing connector in place, preserving its id and key.
+ *
+ * Endpoint: PUT {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors/{id}
+ *
+ * The server upserts the full connector body under the supplied id, so the
+ * caller must pass the complete connector (e.g. the body returned by
+ * `importConnectorZip`).
+ */
+export declare function updateDesignConnector(options: CreateApiClientOptions | undefined, connectorId: number, connector: ImportedConnector): Promise<PersistedConnector>;
+/**
+ * Find a connector visible to the caller's tenant whose key matches exactly.
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors
+ *
+ * This is the same tenant-scoped connector search the connector builder uses
+ * to list a user's connectors (including design connectors), and it is
+ * available to connector-authoring callers. Results are paged 200 at a time;
+ * paging continues while the `elements-next-page-token` response header is
+ * present and non-empty. Returns the matching connector reference, or `null`
+ * when no connector with that key exists.
+ */
+export declare function findDesignConnectorByKey(options: CreateApiClientOptions | undefined, key: string): Promise<DesignConnectorRef | null>;
+/**
+ * Download an existing connector as a zip.
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors/{id}/export
+ *
+ * Returns the connector packaged in the same on-disk layout the importer
+ * consumes: a single top-level directory (named after the connector key)
+ * containing `app/element/element.json`, `standard-resources/`, the image, and
+ * related files. This is the builder's own export, so it serves design
+ * connectors (unlike the published-element export, which requires a deployed
+ * version).
+ */
+export declare function exportConnectorZip(options: CreateApiClientOptions | undefined, connectorId: number): Promise<Uint8Array>;
+/** Input to publishConnector. Mirrors the connector-builder-ui's POST body. */
+export interface PublishConnectorArgs {
+    /** The design connector's numeric id (from `createDesignConnector` / `findDesignConnectorByKey`). */
+    connectorId: number;
+    /** Semantic version to publish (e.g. "1.0.0"). Server uses this as the element version. */
+    version: string;
+    /** Optional metadata passed through; server defaults derive from the design connector when omitted. */
+    connectorMetadata?: {
+        description?: string;
+        image?: string;
+        latestVersion?: string;
+    };
+}
+/**
+ * Server response from POST /publish/private. The job is async; poll status
+ * with the id.
+ *
+ * Periodic serializes the job's identifier as `id` (`PublishJobLog.id`); it
+ * does NOT return a `publishId` field. `publishId` is kept here as an optional
+ * forward-compat alias in case the server adds it later — callers should read
+ * `id ?? publishId`.
+ */
+export interface PublishJobResult {
+    id?: number | string;
+    publishId?: number | string;
+    status?: string;
+    message?: unknown;
+    [k: string]: unknown;
+}
+/** Server response from GET /publish/private/{publishId}/status. */
+export interface PublishStatusResult {
+    id?: number | string;
+    publishId?: number | string;
+    status: "IN_PROGRESS" | "SUCCESS" | "FAILURE" | string;
+    message?: unknown;
+    [k: string]: unknown;
+}
+/**
+ * Promote a design connector to a tenant-wide CUSTOM connector.
+ *
+ * Endpoint: POST {baseUrl}/{org}/{tenant}/elements_/v3/element/publish/private
+ *
+ * Returns immediately with the job id (server field `id`) — the actual publish
+ * work runs async on the server. Read the id as `id ?? publishId` and poll
+ * `getPublishStatus(id)` until status != "IN_PROGRESS". Studio Web's connector
+ * picker reflects the new connector ~5-10 min after status reaches SUCCESS
+ * (registry propagation).
+ */
+export declare function publishConnector(options: CreateApiClientOptions | undefined, args: PublishConnectorArgs): Promise<PublishJobResult>;
+/**
+ * Poll the status of an in-flight publish job.
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v3/element/publish/private/{publishId}/status
+ *
+ * Status values: IN_PROGRESS (still running), SUCCESS, FAILURE. Server may emit
+ * additional values — surface them as-is.
+ */
+export declare function getPublishStatus(options: CreateApiClientOptions | undefined, publishId: number | string): Promise<PublishStatusResult>;
+/** Lightweight connector summary used by listings and search. */
+export interface ConnectorSummary {
+    id: number;
+    key: string;
+    name?: string;
+    description?: string;
+}
+/**
+ * Retrieve a single connector's full record by numeric id.
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors/{id}
+ */
+export declare function getConnectorById(options: CreateApiClientOptions | undefined, connectorId: number): Promise<PersistedConnector>;
+/**
+ * List connectors visible to the caller's tenant (the same search the connector
+ * builder uses), paged 200 at a time. Accumulates up to `limit` summaries;
+ * `truncated` is true when more existed beyond the cap.
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v3/element/connectors
+ */
+export declare function listConnectors(options: CreateApiClientOptions | undefined, params?: {
+    limit?: number;
+    design?: boolean;
+}): Promise<{
+    items: ConnectorSummary[];
+    truncated: boolean;
+}>;

package/dist/src/index.d.ts

@@ -3,6 +3,7 @@ export * from "../generated/connections/src/index.js";
 export { ElementsApi } from "../generated/elements/src/apis/index.js";
 export * from "../generated/elements/src/models/index.js";
 export { Configuration as ElementsConfiguration } from "../generated/elements/src/runtime.js";
-export { type CreateApiClientOptions, createApiClient, createConnectionsConfig, createElementsConfig, type EventOperationObject, type ExecuteOperationResult, executeOperation, folderOverride, getEventObjectMetadataAsSchema, getEventOperationObjects, getHttpRequestPreview, getInstanceEventObjectMetadataAsSchema, getInstanceObjectMetadataAsSchema, getObjectMetadataAsSchema, getWebhookConfig, type HttpRequestPreviewResult, type InstanceDesignActionResult, runInstanceDesignAction, type WebhookConfigResult, } from "./client-factory.js";
+export { type ConnectorSummary, type CreateApiClientOptions, createApiClient, createConnectionsConfig, createDesignConnector, createElementsConfig, type DesignConnectorRef, type EventOperationObject, type ExecuteOperationResult, executeOperation, exportConnectorZip, findDesignConnectorByKey, folderOverride, getConnectorById, getEventObjectMetadataAsSchema, getEventOperationObjects, getHttpRequestPreview, getInstanceEventObjectMetadataAsSchema, getInstanceObjectMetadataAsSchema, getObjectMetadataAsSchema, getPublishStatus, getValidatedAuthContext, getWebhookConfig, type HttpRequestPreviewResult, type ImportedConnector, type InstanceDesignActionResult, importConnectorZip, listConnectors, type PersistedConnector, type PublishConnectorArgs, type PublishJobResult, type PublishStatusResult, publishConnector, runInstanceDesignAction, updateDesignConnector, type WebhookConfigResult, } from "./client-factory.js";
 export * from "./dap/index.js";
+export { decodeElementsNextPageToken, ELEMENTS_NEXT_PAGE_DONE, type ElementsNextPage, hasMoreElementsPages, } from "./pagination.js";
 export { SDK_USER_AGENT } from "./user-agent.js";

package/dist/src/pagination.d.ts

@@ -0,0 +1,20 @@
+/** Sentinel value `providerNextPage` carries on the last page (periodic `NEXT_PAGE_TOKEN_DONE`). */
+export declare const ELEMENTS_NEXT_PAGE_DONE = "DONE";
+export interface ElementsNextPage {
+    /** Upstream/vendor cursor, or the "DONE" sentinel on the last page. */
+    providerNextPage?: string;
+    page?: number;
+    pageSize?: number;
+}
+/**
+ * Decode an IS/periodic `elements-next-page-token`. Returns the parsed cursor, or
+ * `null` when the token is blank or cannot be decoded into the expected JSON object.
+ */
+export declare const decodeElementsNextPageToken: (token: string | null | undefined) => ElementsNextPage | null;
+/**
+ * Whether `token` points at a genuine next page: it decodes, carries a
+ * `providerNextPage` cursor, and that cursor is not the "DONE" sentinel. Because the
+ * header is always present, THIS — not header presence — is the correct
+ * has-more-pages / loop-continuation predicate for IS/periodic list responses.
+ */
+export declare const hasMoreElementsPages: (token: string | null | undefined) => boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/integrationservice-sdk",
   "license": "MIT",
-  "version": "1.197.0",
+  "version": "1.198.0-preview.80",
   "repository": {
     "type": "git",
     "url": "https://github.com/UiPath/cli.git",
@@ -27,5 +27,5 @@
   "files": [
     "dist"
   ],
-  "gitHead": "56f68b263cec4ea1f2a39d738bd99ecf52f88fea"
+  "gitHead": "9b2c3c0f21a256d2f38dd28bc97e72e6f7b10a9c"
 }