@uipath/integrationservice-sdk 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/src/bindings.d.ts

@@ -0,0 +1,5 @@
+export * from "./dap/activity-bindings.js";
+export * from "./dap/activity-configuration-version.js";
+export * from "./dap/bindings-v2.js";
+export { EXTERNAL_SERVICE_TYPES, externalServiceType, } from "./dap/external-execution.js";
+export { IMPLICIT_CONNECTION } from "./dap/managed-http.js";

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

@@ -22,7 +22,10 @@ export declare function getValidatedAuthContext(options?: CreateApiClientOptions
 }>;
 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>;
+type ConnectionsApiConstructor<T> = new (config: ConnectionsConfiguration) => T;
+type ElementsApiConstructor<T> = new (config: ElementsConfiguration) => T;
+export declare function createApiClient<T>(ApiClass: ConnectionsApiConstructor<T>, options?: CreateApiClientOptions): Promise<T>;
+export declare function createApiClient<T>(ApiClass: ElementsApiConstructor<T>, options?: CreateApiClientOptions): Promise<T>;
 export declare function executeOperation(options: CreateApiClientOptions | undefined, connectionId: string, objectName: string, httpMethod?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", body?: unknown, queryParams?: Record<string, string>, requestOptions?: ExecuteOperationRequestOptions): Promise<ExecuteOperationResult>;
 /**
  * Fetch object metadata as JSON Schema (no connection — base/standard fields only).
@@ -295,3 +298,4 @@ export declare function listConnectors(options: CreateApiClientOptions | undefin
     items: ConnectorSummary[];
     truncated: boolean;
 }>;
+export {};

package/dist/src/connection-lookup.d.ts

@@ -1,4 +1,11 @@
+import { ConnectionsApi } from "../generated/connections/src/apis/ConnectionsApi.js";
+import type { GetConnectionResponse } from "../generated/connections/src/models/GetConnectionResponse.js";
 import { type CreateApiClientOptions } from "./client-factory.js";
+/** Which connections a listing covers. */
+export interface ConnectionListScope {
+    allFolders?: boolean;
+    folderKey?: string;
+}
 /**
  * A connection is addressed two ways: its connection id (UUID) and the
  * element instance id (number) the elements_ service keys it on. Both sit on
@@ -7,10 +14,20 @@ import { type CreateApiClientOptions } from "./client-factory.js";
 export interface ConnectionInstanceIds {
     connectionId: string;
     elementInstanceId: number;
+    /** The connection's connector key, when a lookup read the connection. */
+    connectorKey?: string;
 }
+export declare function isConnectionNotFoundError(error: unknown): boolean;
+/**
+ * Fetch every connection in the scope. A single unpaged call silently
+ * truncates large tenants, which would make delete report a false "not found"
+ * and export ship an incomplete set.
+ */
+export declare function listAllConnections(api: ConnectionsApi, scope?: ConnectionListScope): Promise<GetConnectionResponse[]>;
 /**
- * Fill in whichever of the two connection ids the caller left out. When both
- * are given they are returned as-is, with no request.
+ * Fill in whichever of the two connection ids the caller left out, and report
+ * the connection's connector key. When both ids are given they are returned
+ * as-is, with no request — so nothing checks that they belong together.
  */
 export declare function resolveConnectionInstanceIds(options: CreateApiClientOptions | undefined, ids: {
     connectionId?: string;

package/dist/src/connection-resolver.d.ts

@@ -0,0 +1,41 @@
+import { type CreateApiClientOptions } from "./client-factory.js";
+/** A connection a name lookup found. */
+export interface ConnectionMatch {
+    id: string;
+    name: string;
+    /** The folder's path, or its name when the service sends no path. */
+    folder?: string;
+    folderKey?: string;
+    /** `Enabled`, `Disabled`, `Expired` or `Failed`. */
+    state: string;
+}
+/**
+ * The connections of `connectorKey` named `name`, ignoring case, among those
+ * the caller can see in any folder. A name is unique only within a folder, so
+ * the caller decides what several matches mean.
+ *
+ * Pages until a short page, or a page that adds no connection, in case the
+ * service ignores the paging.
+ */
+export declare function findConnectionsByName(connectorKey: string, name: string, options?: CreateApiClientOptions): Promise<ConnectionMatch[]>;
+/** Where a connection's token goes, and where the connection is stored. */
+export interface ConnectionTarget {
+    id: string;
+    /**
+     * The URL the connection authenticates against: its `base.url`
+     * configuration, or `Service-URL` for a connector that names it so.
+     * Undefined when the connection has neither.
+     */
+    baseUrl?: string;
+    folderKey?: string;
+    /** The folder's path, or its name when the service sends no path. */
+    folder?: string;
+    /** Whether the folder is a personal workspace. */
+    personalWorkspace: boolean;
+}
+/**
+ * Read one connection with its configuration, in any folder the caller can
+ * see: the base URL its token is for, and its folder. Throws the runtime's
+ * error for a connection the caller cannot see.
+ */
+export declare function getConnectionTarget(connectionId: string, options?: CreateApiClientOptions): Promise<ConnectionTarget>;

package/dist/src/connections.d.ts

@@ -0,0 +1,3 @@
+import "./user-agent.js";
+export type { CreateApiClientOptions } from "./client-factory.js";
+export { type ConnectionMatch, type ConnectionTarget, findConnectionsByName, getConnectionTarget, } from "./connection-resolver.js";

package/dist/src/dap/activity-configuration-version.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The context entry that tells the designers a connector node was configured
+ * in the V2 panel. Without it a Case task, rule or trigger opens in the V1
+ * panel unless the case itself carries the V2 marker, which the Case Designer
+ * stops stamping once a case has configured activities.
+ */
+export declare const ACTIVITY_CONFIGURATION_VERSION = "activityConfigurationVersion";
+export declare const v2ConfigurationVersionEntry: () => {
+    name: string;
+    type: "string";
+    value: string;
+};

package/dist/src/dap/bindings-v2.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The `bindings_v2.json` rows an Integration Service node packages into, shared
+ * by every host that writes them (Flow, Case, BPMN). Pure and import-free, so a
+ * browser-targeted bundle can take it without the rest of the SDK.
+ */
+/** `metadata.BindingsVersion` on every resource. */
+export declare const BINDINGS_VERSION = "2.2";
+/** Studio Web's guard on a JSON-looking string it stores in node metadata, stripped when it packages the value. */
+export declare const JSON_STRING_PREFIX = "=jsonString:";
+/** `json` guarded the way a node's `configuration` stores it. */
+export declare const guardJsonString: (json: string) => string;
+export declare const stripJsonStringGuard: (value: string) => string;
+/** A copy of `value` with `map` applied to every string inside it, at any depth. */
+export declare function mapStringsDeep<T>(value: T, map: (text: string) => string): T;
+/** `value` with the guard stripped from every string inside it. */
+export declare const restoreJsonStringsDeep: <T>(value: T) => T;
+/** Placed in `=bindings.{{CONN_BINDING_ID}}` for the consumer to replace with its connection binding id. */
+export declare const CONN_BINDING_ID_PLACEHOLDER = "{{CONN_BINDING_ID}}";
+/** Placed in `=bindings.{{FOLDER_BINDING_ID}}` for the connection's folder binding id. */
+export declare const FOLDER_BINDING_ID_PLACEHOLDER = "{{FOLDER_BINDING_ID}}";
+/** How every resource picker placeholder starts, before the field name. */
+export declare const RESOURCE_BINDING_ID_PREFIX = "{{RESOURCE_BINDING_ID:";
+/** Placed in a resolved picker's input as `=bindings.{{RESOURCE_BINDING_ID:<field>}}`. */
+export declare const resourceBindingIdPlaceholder: (field: string) => string;
+/** Any of the placeholders above. */
+export declare const BINDING_ID_PLACEHOLDER_PATTERN: RegExp;
+export type BindingsV2Value = {
+    defaultValue: string;
+    isExpression: boolean;
+};
+export type BindingsV2Row = {
+    resource: string;
+    key: string;
+    id?: string;
+    value: Record<string, BindingsV2Value>;
+    metadata?: Record<string, string>;
+};
+/** The EventTrigger key: the connection plus the node, so two triggers on one connection stay apart. */
+export declare const eventTriggerResourceKey: (connectionKey: string, nodeId: string) => string;
+export interface EventTriggerResourceSpec {
+    connectionKey: string;
+    nodeId: string;
+    /** Left out of `value` when absent, rather than invented. */
+    entryPointId?: string;
+    connector?: string;
+    activityName?: string;
+    objectName?: string;
+    operation?: string;
+    filterExpression?: string;
+}
+/**
+ * A connector trigger's `EventTrigger` resource. Without it a deployed process
+ * never gets its Integration Service trigger.
+ */
+export declare function buildEventTriggerResource(spec: EventTriggerResourceSpec): BindingsV2Row;
+export interface StoredBindingOwner {
+    nodeId: string;
+    activityName?: string;
+    /** `EventTrigger.<key>` for a trigger, `Connection.<key>` for any other node. */
+    parentResourceKey: string;
+    /**
+     * Re-key a Property bag keyed by the bare operation under its parent, as
+     * Studio Web packages it, so two nodes on one operation stay apart.
+     */
+    operation?: string;
+}
+/**
+ * One row of a node's stored `metadata.bindings` as it is packaged: guard
+ * stripped, named for the node, and a Property bag tied to the node and its
+ * parent.
+ */
+export declare function packageStoredBinding<T extends Record<string, unknown>>(row: T, owner: StoredBindingOwner): T;
+export interface ParameterPropertySpec {
+    key: string;
+    nodeId: string;
+    parameters: Record<string, unknown>;
+    activityName?: string;
+    objectName?: string;
+    parentResourceKey: string;
+}
+/** A trigger's Property bag built from its event parameters, for a node that stored none. */
+export declare function buildParameterPropertyResource(spec: ParameterPropertySpec): BindingsV2Row;
+export interface RootResourceBinding {
+    id: string;
+    name?: string;
+    type?: string;
+    resource?: string;
+    resourceKey?: string;
+    propertyAttribute?: string;
+    default?: string;
+}
+/**
+ * The root binding for one resolved picker row, matched on resource, key and
+ * attribute so a repeated configure refreshes the row instead of adding one.
+ * A matched row with no id gets one, since callers reference it by id.
+ * The caller inserts a `created` binding where its document keeps them.
+ */
+export declare function upsertResourceBinding<T extends RootResourceBinding>(bindings: readonly T[], row: {
+    resource: string;
+    resourceKey: string;
+    propertyAttribute: string;
+    name: string;
+    default: string | undefined;
+}, mintId: () => string): {
+    binding: T;
+    created: boolean;
+};

package/dist/src/dap/essential-config.d.ts

@@ -1,4 +1,5 @@
 import type { DesignTimeFilterTree, IDesignTimeActivityClient } from "@uipath/integration-service-design-time";
+import { MANAGED_HTTP_CONNECTOR_KEY } from "./managed-http.js";
 import { type ResolvedResourceField } from "./resource-field-resolver.js";
 import type { ConnectorMethodInfo, CustomFieldsRequestDetails } from "./types.js";
 /**
@@ -6,7 +7,7 @@ import type { ConnectorMethodInfo, CustomFieldsRequestDetails } from "./types.js
  * The managed HTTP node proxies requests through this connector, using the
  * target connector's IS connection for authentication.
  */
-export declare const MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
+export { MANAGED_HTTP_CONNECTOR_KEY };
 export declare const MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
 /**
  * Build the OFFLINE (no-fetch) essential-only configuration blob for an activity connector node from

package/dist/src/dap/external-execution.d.ts

@@ -0,0 +1,35 @@
+export interface ExternalExecution {
+    /** `sync`, `async` or `hybrid`. */
+    executionType: string;
+    /** The event an `async` / `hybrid` agent or automation answers with. */
+    eventType?: string;
+    eventMode?: string;
+}
+/**
+ * An external agent or automation object (one whose IS metadata carries an
+ * `executionType`), read the way the design-time package reads it: an `async`
+ * or `hybrid` one answers through its first event mode's first event type.
+ */
+export declare function externalExecutionOf(metadata: unknown): ExternalExecution | undefined;
+/**
+ * Why a node built from `external` may never finish, or undefined. Studio Web
+ * saves such a node without a word, so the CLI warns rather than refuses.
+ */
+export declare function externalExecutionWarning(external: ExternalExecution, target: string): string | undefined;
+/** The node types an external agent or automation is saved as, by execution. */
+export declare const EXTERNAL_SERVICE_TYPES: {
+    readonly agent: {
+        readonly sync: "Intsvc.SyncAgentExecution";
+        readonly async: "Intsvc.AsyncAgentExecution";
+    };
+    readonly workflow: {
+        readonly sync: "Intsvc.SyncWorkflowExecution";
+        readonly async: "Intsvc.AsyncWorkflowExecution";
+    };
+};
+/**
+ * The node type an external agent or automation is saved as for its execution
+ * type, as Studio Web's `determineActualIntsvcType` remaps it (`hybrid` runs as
+ * `async`). An execution type it leaves alone gives `undefined`.
+ */
+export declare function externalServiceType(kind: "agent" | "workflow", executionType: string | undefined): string | undefined;

package/dist/src/dap/index.d.ts

@@ -1,8 +1,10 @@
 export type { DesignTimeBindingResource, DesignTimeResourceField, DesignTimeResourceSelection, DesignTimeSolutionResourceConfiguration, SolutionResourceConfigurationsProvider, } from "@uipath/integration-service-design-time";
 export { planResourceBindings, type ResourceBindingPlan, type ResourceBindingRow, storedActivityBindings, } from "./activity-bindings.js";
 export { applySavedFilterTree, assertActivityMetadataResolved, buildActivityEssentialConfiguration, buildManagedHttpEssentialConfiguration, type ConfigureActivityClientOptions, type ConfiguredActivityClient, configureActivityClient, createConfiguredActivityClient, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_CONNECTOR_VERSION, } from "./essential-config.js";
+export { type ExternalExecution, externalExecutionOf, externalExecutionWarning, } from "./external-execution.js";
 export * from "./filter-builder/index.js";
 export { buildInputMetadata, extractMultipartParameters, inlineMultipartFileValues, isListOperation, resolveMultipartOperationMetadata, } from "./input-metadata.js";
+export { buildManagedHttpBodyParameters, IMPLICIT_CONNECTION, MANAGED_HTTP_ACTIVITY_TYPE_ID, MANAGED_HTTP_ENDPOINT, MANAGED_HTTP_METHODS, MANAGED_HTTP_OBJECT_NAME, MANAGED_HTTP_TELEMETRY, type ManagedHttpConnectorDetail, type ManagedHttpDetail, type ManagedHttpManualDetail, managedHttpDetailErrors, } from "./managed-http.js";
 export { type ResolvedResourceField, ResourceFieldResolutionError, resolveResourceFieldValues, resourceFolderKeyFieldName, } from "./resource-field-resolver.js";
 export { createSolutionResourceConfigurationsProvider, type SolutionResourceEngine, } from "./solution-resource-configurations.js";
 export type { ConnectorMethodInfo, CustomFieldsRequestDetails, FieldDesign, FieldReference, InputMetadata, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, MultipartFileField, MultipartOperationMetadata, MultipartParam, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./types.js";

package/dist/src/dap/managed-http.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The managed HTTP request node (`Intsvc.UnifiedHttpRequest`, connector
+ * `uipath-uipath-http`): what a caller authors and the request body Studio Web
+ * saves for it, shared by every host that builds one (Flow, BPMN).
+ */
+export declare const MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
+export declare const MANAGED_HTTP_OBJECT_NAME = "http-request";
+/** Studio's HTTP Request activity type, the same on every tenant. */
+export declare const MANAGED_HTTP_ACTIVITY_TYPE_ID = "5c4cc855-b42a-37e6-b910-de8588998fce";
+export declare const MANAGED_HTTP_ENDPOINT = "/http-request";
+/** The connection a manual-mode request names, since it authenticates itself. */
+export declare const IMPLICIT_CONNECTION = "ImplicitConnection";
+export declare const MANAGED_HTTP_METHODS: ReadonlySet<string>;
+export interface ManagedHttpConnectorDetail {
+    authentication: "connector";
+    method: string;
+    connectionId: string;
+    folderKey: string;
+    targetConnector: string;
+    /** The endpoint on the target connector, e.g. "/conversations.replies"; fills both `path` and `url`. */
+    url?: string;
+    headers?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+}
+export interface ManagedHttpManualDetail {
+    authentication: "manual";
+    method: string;
+    url: string;
+    headers?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+}
+export type ManagedHttpDetail = ManagedHttpConnectorDetail | ManagedHttpManualDetail;
+/** Everything wrong with `config` as a managed HTTP detail; empty when it is one. */
+export declare function managedHttpDetailErrors(config: Record<string, unknown>): string[];
+/** The node's `body` input: the request the HTTP connector sends, as Studio Web saves it. */
+export declare function buildManagedHttpBodyParameters(detail: ManagedHttpDetail): Record<string, unknown>;
+/** `metadata.telemetryData` Studio Web writes for the node. */
+export declare const MANAGED_HTTP_TELEMETRY: {
+    readonly connectorKey: "uipath-uipath-http";
+    readonly connectorName: "HTTP";
+    readonly operationType: "create";
+    readonly objectName: "http-request";
+    readonly objectDisplayName: "HTTP Request";
+    readonly primaryKeyName: "";
+};

package/dist/src/dap/resource-field-resolver.d.ts

@@ -10,7 +10,11 @@ export declare function resourceFolderKeyFieldName(fieldName: string): string;
 /** A resource-picker value the caller already resolved, as opposed to a plain parameter value. */
 export declare function isResourceSelection(value: unknown): value is DesignTimeResourceSelection;
 export declare class ResourceFieldResolutionError extends Error {
-    constructor(message: string);
+    /** The authored value is what's wrong (several matches, a list, a non-string), not the tenant or solution. */
+    readonly fromInput: boolean;
+    constructor(message: string, 
+    /** The authored value is what's wrong (several matches, a list, a non-string), not the tenant or solution. */
+    fromInput?: boolean);
 }
 /**
  * Replaces each picker field's authored name in `fieldValues` with the selection the design-time client

package/dist/src/index.d.ts

@@ -1,14 +1,16 @@
 import "./user-agent.js";
-export type { DesignTimeFilterTree } from "@uipath/integration-service-design-time";
+export type { DesignTimeFilterFields, DesignTimeFilterTree, } from "@uipath/integration-service-design-time";
 export * from "../generated/connections/src/index.js";
+export { type ElementMetadata, ElementMetadataFromJSON, ElementMetadataFromJSONTyped, ElementMetadataToJSON, ElementMetadataToJSONTyped, instanceOfElementMetadata, instanceOfStandardResourceFieldAction, instanceOfStandardResourceFieldActionRules, instanceOfStandardResourceFieldDesign, instanceOfStandardResourceFieldEnum, instanceOfStandardResourceFieldEventMetadata, instanceOfStandardResourceFieldMethod, instanceOfStandardResourceFieldMethodDesign, instanceOfStandardResourceFieldReference, instanceOfStandardResourceHydration, instanceOfStandardResourceMetadataMethodParameter, instanceOfTemplateProperties, type StandardResourceFieldAction, StandardResourceFieldActionFromJSON, StandardResourceFieldActionFromJSONTyped, type StandardResourceFieldActionRules, StandardResourceFieldActionRulesFromJSON, StandardResourceFieldActionRulesFromJSONTyped, StandardResourceFieldActionRulesToJSON, StandardResourceFieldActionRulesToJSONTyped, StandardResourceFieldActionToJSON, StandardResourceFieldActionToJSONTyped, type StandardResourceFieldDesign, StandardResourceFieldDesignFromJSON, StandardResourceFieldDesignFromJSONTyped, StandardResourceFieldDesignToJSON, StandardResourceFieldDesignToJSONTyped, type StandardResourceFieldEnum, StandardResourceFieldEnumFromJSON, StandardResourceFieldEnumFromJSONTyped, StandardResourceFieldEnumToJSON, StandardResourceFieldEnumToJSONTyped, type StandardResourceFieldEventMetadata, StandardResourceFieldEventMetadataFromJSON, StandardResourceFieldEventMetadataFromJSONTyped, StandardResourceFieldEventMetadataToJSON, StandardResourceFieldEventMetadataToJSONTyped, type StandardResourceFieldMethod, type StandardResourceFieldMethodDesign, StandardResourceFieldMethodDesignFromJSON, StandardResourceFieldMethodDesignFromJSONTyped, StandardResourceFieldMethodDesignToJSON, StandardResourceFieldMethodDesignToJSONTyped, StandardResourceFieldMethodFromJSON, StandardResourceFieldMethodFromJSONTyped, StandardResourceFieldMethodToJSON, StandardResourceFieldMethodToJSONTyped, type StandardResourceFieldReference, StandardResourceFieldReferenceFromJSON, StandardResourceFieldReferenceFromJSONTyped, StandardResourceFieldReferenceToJSON, StandardResourceFieldReferenceToJSONTyped, type StandardResourceHydration, StandardResourceHydrationFromJSON, StandardResourceHydrationFromJSONTyped, StandardResourceHydrationToJSON, StandardResourceHydrationToJSONTyped, type StandardResourceMetadataMethodParameter, StandardResourceMetadataMethodParameterFromJSON, StandardResourceMetadataMethodParameterFromJSONTyped, StandardResourceMetadataMethodParameterToJSON, StandardResourceMetadataMethodParameterToJSONTyped, type TemplateProperties, TemplatePropertiesFromJSON, TemplatePropertiesFromJSONTyped, TemplatePropertiesToJSON, TemplatePropertiesToJSONTyped, } from "../generated/connections/src/models/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 { ACTIVITY_VERSION_V4, type ConnectorSummary, type CreateApiClientOptions, createApiClient, createConnectionsConfig, createDesignConnector, createElementsConfig, type DesignConnectorRef, type EventOperationObject, type ExecuteOperationRequestOptions, type ExecuteOperationResult, executeOperation, exportConnectorZip, findDesignConnectorByKey, folderOverride, getConnectorActivityMetadataV4, getConnectorById, getEventObjectMetadataAsSchema, getEventOperationObjects, getHttpRequestPreview, getInstanceEventObjectMetadataAsSchema, getInstanceObjectMetadataAsSchema, getObjectMetadataAsSchema, getPublishStatus, getValidatedAuthContext, getWebhookConfig, type HttpRequestPreviewResult, type ImportedConnector, type InstanceDesignActionResult, importConnectorZip, isV4ActivityConfiguration, listConnectors, type PersistedConnector, type PublishConnectorArgs, type PublishJobResult, type PublishStatusResult, publishConnector, runInstanceDesignAction, SUPPORTED_ACTIVITY_VERSIONS, updateDesignConnector, type WebhookConfigResult, } from "./client-factory.js";
-export { type ConnectionInstanceIds, resolveConnectionInstanceIds, } from "./connection-lookup.js";
+export { type ConnectionInstanceIds, type ConnectionListScope, isConnectionNotFoundError, listAllConnections, resolveConnectionInstanceIds, } from "./connection-lookup.js";
+export { type ConnectionMatch, findConnectionsByName, } from "./connection-resolver.js";
 export { normalizeConnectionStatus } from "./connection-state.js";
 export * from "./dap/index.js";
-export { type ApiAction, apiActionRequirements, applyDesignActionRemap, findApiAction, matchApiAction, type RequestPicker, type ResolvedSolutionResource, resourcePickersRequestNeeds, runDesignAction, } from "./metadata/design-actions.js";
+export { type ApiAction, apiActionRequirements, applyDesignActionRemap, ConflictingDesignActionsError, findApiAction, matchApiAction, type RequestPicker, type ResolvedSolutionResource, resourcePickersRequestNeeds, runDesignAction, } from "./metadata/design-actions.js";
 export { buildResourceCompactSummary, buildTriggerCompactSummary, CRUD_OPERATIONS, fetchRawMetadata, fetchTriggerMetadata, fetchTriggerObjects, normalizeObjectsList, } from "./metadata/resource-metadata.js";
 export { applyTriggerDesignActionRemap, findTriggerDesignAction, runTriggerDesignAction, type TriggerEventTarget, triggerEventParameters, } from "./metadata/trigger-design-actions.js";
 export { decodeElementsNextPageToken, ELEMENTS_NEXT_PAGE_DONE, type ElementsNextPage, hasMoreElementsPages, } from "./pagination.js";

package/dist/src/metadata/design-actions.d.ts

@@ -43,16 +43,70 @@ export declare function apiActionRequirements(metadata: Record<string, unknown>,
  *   fallback regardless of method.
  * @param fieldValues The field values supplied by the user, by field name
  *   (e.g. `{ "fields.project.key": "ENGCE" }`). An empty value is a cleared
- *   field, so it satisfies only a rule that asks for one (`isCleared`).
- * @param actionName Optional explicit action name to disambiguate when more than
- *   one action matches.
+ *   field, so it satisfies only a rule that asks for one (`isCleared`). Keys
+ *   are in the order the user supplied them, which decides the action when
+ *   several match ({@link matchApiAction}).
+ * @param actionName Optional explicit action name, which picks one action
+ *   when the values satisfy several.
+ * @throws ConflictingDesignActionsError when the deciding field has more than
+ *   one satisfied action and no `actionName` picks one.
  */
 export declare function findApiAction(metadata: Record<string, unknown>, httpMethod: string, fieldValues: Record<string, string>, actionName?: string): ApiAction | null;
+/**
+ * The inputs Studio Web renders as a button: a field whose design override
+ * for the operation, or else its own design, says `component: "Button"`
+ * (`FieldExtensions` + `FieldDesignExtensions.override`), and a parameter
+ * whose design does. `designOverrides` picks a field's override.
+ */
+export declare function buttonInputNames(fields: unknown, parameters: unknown, designOverrides: (field: DesignField) => unknown): Set<string>;
+/**
+ * The supplied values satisfy more than one design action keyed on the same
+ * field. Studio Web refuses this too: `ConnectorActionsService
+ * .getCustomFieldsObjectAction` throws `ConflictingObjectActionsFound` rather
+ * than pick one.
+ */
+export declare class ConflictingDesignActionsError extends Error {
+    readonly actionNames: string[];
+    readonly fieldName: string;
+    readonly requirements: Array<{
+        name: string;
+        refFieldNames: string[];
+    }>;
+    constructor(actionNames: string[], fieldName: string, requirements?: Array<{
+        name: string;
+        refFieldNames: string[];
+    }>);
+}
 /**
  * {@link findApiAction} over a raw list of actions, such as a trigger event
  * object's `design.actions`; other action types (e.g. `reset`) are skipped.
+ * `buttons` names the inputs that are buttons ({@link buttonInputNames}).
+ *
+ * Studio Web runs a design action when a field changes, and only an action
+ * whose rules name that field (`ConnectorActionsProcessor` keys each action
+ * on every field its rules name; `getCustomFieldsObjectAction(refFieldName)`
+ * reads that field's list). The CLI has no "field just changed", so it takes
+ * the fields in the order they were supplied (`fieldValues`' key order) and
+ * reads them from the last: the first field with a satisfied action keyed on
+ * it decides, as the last field a user sets in Studio Web decides the schema.
+ * Two or more satisfied actions on that field throw
+ * {@link ConflictingDesignActionsError}. Rules are checked against all the
+ * supplied values, not the values as they stood when each field was set.
+ *
+ * Unlike Studio Web, a tie counts only api actions: the CLI runs no `reset`
+ * or `asyncHandler` action, so one of those never ties with an api action.
+ *
+ * `actionName` skips the field order: that action runs if its rules hold,
+ * even an action whose rules name no field.
+ *
+ * This and {@link ruleSatisfied} port Studio Web's matcher by hand. They go
+ * away once Studio Web ships it in a package the CLI can call
+ * (https://github.com/UiPath/StudioWeb/issues/22591).
+ *
+ * @throws ConflictingDesignActionsError when the deciding field has more than
+ *   one satisfied action and no `actionName` picks one.
  */
-export declare function matchApiAction(actions: readonly Record<string, unknown>[], fieldValues: Record<string, string>, actionName?: string): ApiAction | null;
+export declare function matchApiAction(actions: readonly Record<string, unknown>[], fieldValues: Record<string, string>, actionName: string | undefined, buttons: ReadonlySet<string>): ApiAction | null;
 type DesignTime = typeof import("@uipath/integration-service-design-time");
 export declare const loadDesignTime: () => Promise<DesignTime>;
 /** A solution-resource picker field's resolved resource. */
@@ -100,15 +154,27 @@ export declare function runDesignAction(options: CreateApiClientOptions | undefi
  * IS Element schema, so downstream consumers (buildResourceCompactSummary)
  * keep working unchanged.
  *
- * Modes (mirroring SW FieldProcessingMode applied to fields and parameters):
+ * Modes (mirroring SW FieldProcessingMode):
  *   - replace  → response wins on the selected request or response side.
  *   - append   → existing fields are kept; response fields are added (response
  *                wins on key conflict so re-fetches stay current).
  *   - prepend  → response fields are added but existing values win on conflict.
- *   - noop     → that side is kept unchanged. Parameters follow input mode.
+ *   - noop     → that side is kept unchanged.
+ *
+ * The modes apply to fields only. The method's query, path, header and
+ * multipart parameters always stay the static ones, and any parameters in the
+ * response are ignored: Studio Web reads only `fields` from the response
+ * (`CustomFieldsDetails`), remaps those in
+ * `fields-service.ts` `_getCustomFieldsDetails`, and then adds the static
+ * `method.parameters` from `_getFieldDetails` in `_computeInputFields`.
  */
 export declare function applyDesignActionRemap(baseMeta: Record<string, unknown>, responseMeta: Record<string, unknown>, httpMethod: string, onSuccess: {
     input: string;
     output: string;
 }): Record<string, unknown>;
+/** A schema field as the IS Element metadata carries it. */
+export interface DesignField extends Record<string, unknown> {
+    name?: string;
+    method?: Record<string, Record<string, unknown>>;
+}
 export {};

package/dist/src/metadata/trigger-design-actions.d.ts

@@ -20,7 +20,9 @@ export interface TriggerEventTarget {
  * The event object's design action the supplied field values satisfy, routed
  * as the design-time package routes it: a `/metadata` URL goes to the event
  * object's metadata route as a GET with no body; any other URL keeps its
- * declared method on the connector's own route. `null` when none matches.
+ * declared method on the connector's own route. `null` when none matches;
+ * throws `ConflictingDesignActionsError` when the deciding field has several
+ * ({@link matchApiAction}) and no `actionName` picks one.
  */
 export declare function findTriggerDesignAction(eventObject: Record<string, unknown>, fieldValues: Record<string, string>, target: TriggerEventTarget, actionName?: string): Promise<ApiAction | null>;
 /** The event object's raw `parameters`, where a trigger declares its pickers. */

package/package.json

@@ -2,7 +2,7 @@
     "name": "@uipath/integrationservice-sdk",
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.205.0-preview.281",
+    "version": "1.206.0-preview.282",
     "repository": {
         "type": "git",
         "url": "https://github.com/UiPath/cli.git",
@@ -23,13 +23,21 @@
         ".": {
             "types": "./dist/src/index.d.ts",
             "default": "./dist/index.js"
+        },
+        "./bindings": {
+            "types": "./dist/src/bindings.d.ts",
+            "default": "./dist/bindings.js"
+        },
+        "./connections": {
+            "types": "./dist/src/connections.d.ts",
+            "default": "./dist/connections.js"
         }
     },
     "files": [
         "dist"
     ],
     "dependencies": {
-        "@uipath/integration-service-design-time": "2.10.0"
+        "@uipath/integration-service-design-time": "3.3.0"
     },
-    "gitHead": "03b01866007f70eea9464da2dceb191a6fc3fb77"
+    "gitHead": "9f18b69f2307838e3ce650b91de76cf6c9a23c13"
 }