@uipath/integrationservice-sdk 1.204.0-preview.255 → 1.205.0-preview.256

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

@@ -69,13 +69,15 @@ export interface InstanceDesignActionResult {
  * `GenerateSchema`, Salesforce `GenerateQuerySchema`) against the IS Element
  * Service. The caller supplies an already-substituted relative URL and, for
  * POST actions, an already-substituted body map; this helper only handles
- * auth, base-path concatenation, and JSON serialization.
+ * auth, base-path concatenation, and JSON serialization. Body values are
+ * usually strings, but a solution-resource configuration graph goes as an
+ * array of objects.
  *
  * The relative URL is appended to `/instances/<connectionOrInstanceId>` under
  * the same `elements_/v3/element` base used by `getInstanceObjectMetadataAsSchema`.
  * Query strings already present in `relativeUrl` are preserved verbatim.
  */
-export declare function runInstanceDesignAction(options: CreateApiClientOptions | undefined, connectionOrInstanceId: string, method: string, relativeUrl: string, body?: Record<string, string> | null): Promise<InstanceDesignActionResult>;
+export declare function runInstanceDesignAction(options: CreateApiClientOptions | undefined, connectionOrInstanceId: string, method: string, relativeUrl: string, body?: Record<string, unknown> | null): Promise<InstanceDesignActionResult>;
 /**
  * Fetch event operation metadata as JSON Schema (no connection).
  */

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

@@ -0,0 +1,18 @@
+import { type CreateApiClientOptions } from "./client-factory.js";
+/**
+ * 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
+ * the same connection record, so either one determines the other.
+ */
+export interface ConnectionInstanceIds {
+    connectionId: string;
+    elementInstanceId: number;
+}
+/**
+ * Fill in whichever of the two connection ids the caller left out. When both
+ * are given they are returned as-is, with no request.
+ */
+export declare function resolveConnectionInstanceIds(options: CreateApiClientOptions | undefined, ids: {
+    connectionId?: string;
+    elementInstanceId?: number;
+}): Promise<ConnectionInstanceIds>;

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

@@ -0,0 +1,21 @@
+import type { DesignTimeBindingResource } from "@uipath/integration-service-design-time";
+import type { ResolvedResourceField } from "./resource-field-resolver.js";
+export interface ResourceBindingRow {
+    /** The picker itself, or its `_folderKey` companion. */
+    field: string;
+    propertyAttribute: "name" | "folderKey";
+    name: string;
+    default: string;
+}
+export interface ResourceBindingPlan {
+    resource: string;
+    resourceKey: string;
+    /** The picker's own row first, then its folder-key row when the folder resolved. */
+    rows: ResourceBindingRow[];
+}
+/** What a host stores on the node or task; a trigger's Property bag is kept, since only the activity produces it. */
+export declare function storedActivityBindings<T extends {
+    resource: string;
+}>(bindings: readonly T[]): T[];
+/** The rows each resolved picker needs; Flow mints them with real ids, a case task with placeholders. */
+export declare function planResourceBindings(stored: readonly DesignTimeBindingResource[], resolved: readonly ResolvedResourceField[]): ResourceBindingPlan[];

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

@@ -1,4 +1,5 @@
 import type { DesignTimeFilterTree, IDesignTimeActivityClient } from "@uipath/integration-service-design-time";
+import { type ResolvedResourceField } from "./resource-field-resolver.js";
 import type { ConnectorMethodInfo, CustomFieldsRequestDetails } from "./types.js";
 /**
  * Connector key and version for the managed HTTP node (core.action.http.v2).
@@ -23,6 +24,22 @@ export declare const MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
  * parameter coverage — the caller supplies a payload the runtime will accept.
  */
 export declare function buildActivityEssentialConfiguration(instanceParameters: Record<string, unknown>, methodInfo: ConnectorMethodInfo, savedFilterTrees?: Record<string, DesignTimeFilterTree> | null, customFieldsRequestDetails?: CustomFieldsRequestDetails | null): Record<string, unknown>;
+export interface ConfigureActivityClientOptions {
+    instanceParameters: Record<string, unknown>;
+    connectionId: string;
+    savedFilterTrees?: Record<string, DesignTimeFilterTree> | null;
+    customFieldsRequestDetails?: CustomFieldsRequestDetails | null;
+    fieldValues?: Record<string, unknown> | null;
+    /** The solution resource pickers are referenced into; without it a picker's plain name is not resolved, and the client skips it. */
+    solutionDir?: string | null;
+}
+export interface ConfiguredActivityClient {
+    client: IDesignTimeActivityClient;
+    /** What `solutionDir` resolved, for the caller to write back into its own buckets and bindings. */
+    resolvedResources: ResolvedResourceField[];
+}
+/** {@link configureActivityClient} for callers that need only the client. */
+export declare function createConfiguredActivityClient(options: ConfigureActivityClientOptions): Promise<IDesignTimeActivityClient>;
 /**
  * Build a fully-configured design-time activity client and return it for the caller to hold and read
  * from. Fetches the connector's metadata from Integration Service — using the logged-in platform
@@ -44,6 +61,10 @@ export declare function buildActivityEssentialConfiguration(instanceParameters:
  *     trigger's event parameters). The activity fills its property grid from them, so reads that depend on
  *     field values — required-field validation and a trigger's mandatory filter — see what the caller set.
  *     Applied after the custom-field replay so fields that only appear after a `GenerateSchema` fetch exist.
+ *     A solution-resource picker takes a `DesignTimeResourceSelection` there.
+ *   - `solutionDir` turns on resource-picker resolution: once the connection is bound, each picker's authored
+ *     name in `fieldValues` is resolved to a solution resource in that solution, before the replay reads it.
+ *     `fieldValues` is updated in place: each resolved picker holds its selection and its companion is removed.
  *
  * The caller holds the returned client and reads it through its getters (`getEssentialConfiguration()`),
  * so a single metadata fetch serves every read instead of re-fetching per call. Pass the resulting
@@ -52,13 +73,7 @@ export declare function buildActivityEssentialConfiguration(instanceParameters:
  *
  * Requires a `connectionId` — the connector's metadata cannot be fetched without a connection.
  */
-export declare function createConfiguredActivityClient({ instanceParameters, connectionId, savedFilterTrees, customFieldsRequestDetails, fieldValues, }: {
-    instanceParameters: Record<string, unknown>;
-    connectionId: string;
-    savedFilterTrees?: Record<string, DesignTimeFilterTree> | null;
-    customFieldsRequestDetails?: CustomFieldsRequestDetails | null;
-    fieldValues?: Record<string, unknown> | null;
-}): Promise<IDesignTimeActivityClient>;
+export declare function configureActivityClient({ instanceParameters, connectionId, savedFilterTrees, customFieldsRequestDetails, fieldValues, solutionDir, }: ConfigureActivityClientOptions): Promise<ConfiguredActivityClient>;
 /**
  * Apply one filter tree to a live client as a FilterBuilder edit — the same edit
  * {@link createConfiguredActivityClient} makes, exposed on its own so a caller can hand the client a

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

@@ -1,6 +1,10 @@
-export { applySavedFilterTree, assertActivityMetadataResolved, buildActivityEssentialConfiguration, buildManagedHttpEssentialConfiguration, createConfiguredActivityClient, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_CONNECTOR_VERSION, } from "./essential-config.js";
+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 * from "./filter-builder/index.js";
 export { buildInputMetadata, extractMultipartParameters, inlineMultipartFileValues, isListOperation, resolveMultipartOperationMetadata, } from "./input-metadata.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";
 export type { ConnectorValidationContext, Issue, IssueType, ValidationRule, } from "./validation/index.js";
 export { DEFAULT_RULES, METHOD_TO_OPERATION, normalizeHttpMethod, OPERATION_TO_METHOD, validateConfiguration, validateConnectionId, validateEndpoint, validateEventMode, validateEventType, validateFolderKey, validateHttpMethod, validateIntSvcNode, validateMethodInMetadata, validateMethodMatchesOperation, validateObjectName, validatePathTemplateParams, validateRequiredEventParameters, validateRequiredFields, validateRequiredParameters, } from "./validation/index.js";

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

@@ -0,0 +1,20 @@
+import type { DesignTimeResourceField, DesignTimeResourceSelection } from "@uipath/integration-service-design-time";
+/** A resource field the resolver settled, with the companion field its folder key travels in. */
+export interface ResolvedResourceField {
+    field: string;
+    companion: string;
+    selection: DesignTimeResourceSelection;
+}
+/** Mirrors the design-time package's companion naming (`NamingHelper.solutionResourceFolderKeyFieldName`). */
+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);
+}
+/**
+ * Replaces each picker field's authored name in `fieldValues` with the selection the design-time client
+ * applies. The `<field>_folderKey` companion narrows an ambiguous lookup; the client writes the resolved
+ * companion itself, so it is dropped from `fieldValues`.
+ */
+export declare function resolveResourceFieldValues(fieldValues: Record<string, unknown>, resourceFields: DesignTimeResourceField[], solutionDir: string): Promise<ResolvedResourceField[]>;

package/dist/src/dap/solution-resource-configurations.d.ts

@@ -0,0 +1,30 @@
+import type { SolutionResourceConfigurationsProvider } from "@uipath/integration-service-design-time";
+/**
+ * The parts of `@uipath/solution-sdk/resources` the provider uses, opened after the login was
+ * refreshed. Declared here so the SDK's published types do not name that dev-only package.
+ */
+export interface SolutionResourceEngine {
+    resources: {
+        readResourceConfigurationsAsync(services: unknown, builder: unknown, resourceKey: string, options: {
+            name?: string;
+        }): Promise<{
+            resources?: unknown[];
+        }>;
+    };
+    services: {
+        getSolutionBuilder(solutionDir: string, readOnly: boolean): Promise<{
+            disposeAsync(): Promise<void>;
+        }>;
+    };
+}
+/**
+ * Reads a picked resource's graph the way `uip solution resources get --include-dependencies` does: from
+ * the solution at `solutionDir` when it declares the key, otherwise from the tenant's resource catalog.
+ * The login is refreshed once, before the first read; each read opens the solution read-only and closes
+ * it again. A failed read names the resource and where it looked, and keeps the cause's HTTP status
+ * (404 for a key found nowhere). `namesByKey` holds names the caller already resolved, which narrow the
+ * catalog search for a key the solution does not declare. A caller that already opened the engine to
+ * resolve the pickers passes it as `openedEngine`, so the login is not refreshed and the engine not
+ * loaded a second time.
+ */
+export declare function createSolutionResourceConfigurationsProvider(solutionDir?: string | null, namesByKey?: ReadonlyMap<string, string>, openedEngine?: SolutionResourceEngine): SolutionResourceConfigurationsProvider;

package/dist/src/index.d.ts

@@ -5,9 +5,12 @@ 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 { 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 { 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";
 export * from "./runtime/index.js";
 export { SDK_USER_AGENT } from "./user-agent.js";

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

@@ -0,0 +1,114 @@
+/**
+ * Design actions: the api-type ObjectActions a connector exposes to fetch a
+ * connection- and parent-field-specific schema at design time (Jira
+ * `GenerateSchema`, Salesforce `GenerateQuerySchema`, Data Service V3
+ * `FetchObjectMetadataTenant`). Studio Web runs them when parent fields
+ * change; these helpers port that logic so CLI commands can do the same.
+ *
+ * Lives in the SDK because more than one tool runs them (`is resources
+ * describe`, `api-workflow registry stub`), and a tool may not import another
+ * tool (AGENTS.md Hard Rule #19).
+ */
+import type { DesignTimeResourceField, SolutionResourceConfigurationsProvider } from "@uipath/integration-service-design-time";
+import { type CreateApiClientOptions } from "../client-factory.js";
+export interface ApiAction {
+    name: string;
+    method: string;
+    url: string;
+    body: Record<string, string> | null;
+    onSuccess: {
+        input: string;
+        output: string;
+    };
+    rules: string[];
+}
+/**
+ * Every api-type design action declared for `httpMethod`, with the field
+ * names its rules depend on. Lets a caller say which field a schema needs
+ * when none of the supplied fields satisfies an action. Same two metadata
+ * shapes as {@link findApiAction}.
+ */
+export declare function apiActionRequirements(metadata: Record<string, unknown>, httpMethod: string): Array<{
+    name: string;
+    refFieldNames: string[];
+}>;
+/**
+ * Locate the api-type ObjectAction whose rules are all satisfied by the
+ * supplied field values. Checks both new (lowercase `actionType: "api"` under
+ * `connectorMethodInfo.design.actions[]`) and old (PascalCase `ActionType: "Api"`
+ * under top-level `objectActions[]`) shapes.
+ *
+ * @param httpMethod The operation's HTTP method (e.g. POST). Used to scope the
+ *   `connectorMethodInfo` lookup. Top-level `objectActions[]` is searched as a
+ *   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.
+ */
+export declare function findApiAction(metadata: Record<string, unknown>, httpMethod: string, fieldValues: Record<string, string>, actionName?: string): ApiAction | null;
+/**
+ * {@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.
+ */
+export declare function matchApiAction(actions: readonly Record<string, unknown>[], fieldValues: Record<string, string>, actionName?: 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. */
+export interface ResolvedSolutionResource {
+    resourceKey: string;
+}
+/** A solution-resource picker a design action's request reads. */
+export interface RequestPicker {
+    /** The picker as the design-time package reports it (`getResourceFieldsFromMetadata`). */
+    field: DesignTimeResourceField;
+    /** Whether the request reads its key through `{=resourceKey(field)}`. */
+    readsKey: boolean;
+    /** The companion field its folder key travels in (`solutionResourceFolderKeyFieldName`). */
+    folderKeyField: string;
+}
+/**
+ * The pickers among `parameters` this action's request needs resolved, by the design-time package's
+ * own rules: a picker is what `getResourceFieldsFromMetadata` reports, and the request reads it when
+ * `getCustomFieldsRequestTokens` finds it in the URL or body. A request with a body needs every picker
+ * it substitutes (their graphs go in the body); any other only those whose key it reads.
+ */
+export declare function resourcePickersRequestNeeds(action: ApiAction, parameters: ReadonlyArray<{
+    name?: unknown;
+    design?: unknown;
+}>): Promise<RequestPicker[]>;
+/**
+ * Build the action's request with the design-time package — the activity's
+ * own token filling, empty-parameter dropping and `{=resourceKey(field)}`
+ * resolution — and send it via the IS Element Service (instance-scoped).
+ * Returns the parsed response body; the caller merges it into the base
+ * metadata via applyDesignActionRemap.
+ *
+ * `solutionResources` (picker field → resolved resource) fills key tokens. On
+ * a POST, PUT or PATCH, `configurationsProvider` reads each resource's graph,
+ * which goes in the body under every value the request sends for it: a local
+ * solution exists only on disk, so the connector reads the definition from the
+ * body. Any other method sends no body, not even a declared one.
+ * URL values are encoded; the body keeps them as authored, since the
+ * connector looks a graph up by the value it decoded from the URL.
+ */
+export declare function runDesignAction(options: CreateApiClientOptions | undefined, connectionId: string, action: ApiAction, fieldValues: Record<string, string>, solutionResources?: Record<string, ResolvedSolutionResource>, configurationsProvider?: SolutionResourceConfigurationsProvider): Promise<Record<string, unknown>>;
+/**
+ * Merge the design-action response into the base metadata according to
+ * the independent input and output remap modes. The shape mirrors the raw
+ * IS Element schema, so downstream consumers (buildResourceCompactSummary)
+ * keep working unchanged.
+ *
+ * Modes (mirroring SW FieldProcessingMode applied to fields and parameters):
+ *   - 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.
+ */
+export declare function applyDesignActionRemap(baseMeta: Record<string, unknown>, responseMeta: Record<string, unknown>, httpMethod: string, onSuccess: {
+    input: string;
+    output: string;
+}): Record<string, unknown>;
+export {};

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

@@ -0,0 +1,45 @@
+/**
+ * Parent-field-driven trigger metadata: a trigger event object's api-type
+ * design action (e.g. Data Fabric's `FetchObjectMetadataFolder`) and how its
+ * fields merge into the event metadata, the way Studio Web's trigger designer
+ * does once the parent fields are picked (UiPath/StudioWeb#22270).
+ *
+ * In the SDK because more than one tool reads a trigger's fields this way
+ * (`is triggers describe`, `maestro case spec --type trigger`).
+ */
+import type { SolutionResourceConfigurationsProvider } from "@uipath/integration-service-design-time";
+import type { CreateApiClientOptions } from "../client-factory.js";
+import { type ApiAction, type ResolvedSolutionResource } from "./design-actions.js";
+/** The trigger an event object belongs to. */
+export interface TriggerEventTarget {
+    connectorKey: string;
+    operation: string;
+    objectName: string;
+}
+/**
+ * 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.
+ */
+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. */
+export declare function triggerEventParameters(eventObject: Record<string, unknown>): Array<{
+    name?: unknown;
+    design?: unknown;
+}>;
+/**
+ * Merge the action's response fields into the event metadata by
+ * `onSuccess.remapConfiguration.input`: `replace` (default) keeps only the
+ * response's fields, `append` and `prepend` keep both (the later one wins on
+ * a name), `noop` keeps the base.
+ */
+export declare function applyTriggerDesignActionRemap(base: Record<string, unknown>, response: Record<string, unknown>, onSuccess: {
+    input: string;
+}): Record<string, unknown>;
+/**
+ * Run a routed trigger design action and return `baseMetadata` with its
+ * fields merged in. `solutionResources` and `configurationsProvider` are as on
+ * {@link runDesignAction}.
+ */
+export declare function runTriggerDesignAction(options: CreateApiClientOptions | undefined, connectionId: string, baseMetadata: Record<string, unknown>, action: ApiAction, fieldValues: Record<string, string>, solutionResources?: Record<string, ResolvedSolutionResource>, configurationsProvider?: SolutionResourceConfigurationsProvider): Promise<Record<string, unknown>>;

package/package.json

@@ -2,7 +2,7 @@
     "name": "@uipath/integrationservice-sdk",
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.204.0-preview.255",
+    "version": "1.205.0-preview.256",
     "repository": {
         "type": "git",
         "url": "https://github.com/UiPath/cli.git",
@@ -29,7 +29,7 @@
         "dist"
     ],
     "dependencies": {
-        "@uipath/integration-service-design-time": "1.41.2"
+        "@uipath/integration-service-design-time": "2.10.0"
     },
-    "gitHead": "699c58dabb59414557755a8933bcbe40aa420df3"
+    "gitHead": "63740c6cbb7ff282fa9118cc16a148eb030b245f"
 }