@uipath/integrationservice-sdk 0.9.1 → 1.1.0

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

@@ -23,6 +23,24 @@ export declare function getObjectMetadataAsSchema(options: CreateApiClientOption
  * Fetch object metadata as JSON Schema (with connection — enriched fields including custom).
  */
 export declare function getInstanceObjectMetadataAsSchema(options: CreateApiClientOptions | undefined, connectionOrInstanceId: string, elementKey: string, objectName: string): Promise<unknown>;
+export interface InstanceDesignActionResult {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    body: unknown;
+}
+/**
+ * Invoke a connector activity's design-time api-type ObjectAction (e.g. Jira
+ * `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.
+ *
+ * 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>;
 /**
  * Fetch event operation metadata as JSON Schema (no connection).
  */
@@ -31,4 +49,43 @@ export declare function getEventObjectMetadataAsSchema(options: CreateApiClientO
  * Fetch event operation metadata as JSON Schema (with connection — enriched event fields).
  */
 export declare function getInstanceEventObjectMetadataAsSchema(options: CreateApiClientOptions | undefined, connectionOrInstanceId: string, elementKey: string, operationName: string, objectName: string): Promise<unknown>;
+/**
+ * Fetch the webhook configuration URL for an Integration Service trigger
+ * that uses eventMode "webhooks".
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v1/webhooks/subscribers/{connectionId}/webhook/config
+ *   ?connectionInstanceId={elementInstanceId}&connectorKey={connectorKey}
+ */
+export declare function getWebhookConfig(options: CreateApiClientOptions | undefined, connectionId: string, elementInstanceId: number, connectorKey: string): Promise<WebhookConfigResult>;
+export interface WebhookConfigResult {
+    webhookUrl: string;
+}
+export interface HttpRequestPreviewResult {
+    url: string;
+}
+/**
+ * Fetch the resolved base URL for a connection's HTTP Request activity.
+ *
+ * Endpoint: POST {baseUrl}/{org}/{tenant}/elements_/v3/element/instances/{connectionId}/http-request-preview
+ */
+export declare function getHttpRequestPreview(options: CreateApiClientOptions | undefined, connectionId: string): Promise<HttpRequestPreviewResult>;
+/**
+ * Fetch event operations for a connector instance to check flags like
+ * byoaConnection and isWebhookUrlVisible.
+ *
+ * Endpoint: GET {baseUrl}/{org}/{tenant}/elements_/v3/element/instances/{elementInstanceId}/elements/{connectorKey}/events/operations/{eventOperation}/objects
+ */
+export declare function getEventOperationObjects(options: CreateApiClientOptions | undefined, elementInstanceId: number, connectorKey: string, eventOperation: string): Promise<EventOperationObject[]>;
+export interface EventOperationObject {
+    name?: string;
+    displayName?: string;
+    eventMode?: string;
+    hideEventIDField?: boolean;
+    debugDisabled?: boolean;
+    isWebhookUrlVisible?: boolean;
+    byoaConnection?: boolean;
+    hasStaticLeftOperandFilterBuilder?: boolean;
+    isHidden?: boolean;
+    supportedAuths?: string[];
+}
 export declare function folderOverride(folderKey?: string): InitOverrideFunction | undefined;

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

@@ -1,5 +1,5 @@
 import type { FilterTree } from "./filter-builder/filter-tree.js";
-import type { ConnectorMethodInfo } from "./types.js";
+import type { ConnectorMethodInfo, CustomFieldsRequestDetails } from "./types.js";
 /**
  * Connector key and version for the managed HTTP node (core.action.http.v2).
  * The managed HTTP node proxies requests through this connector, using the
@@ -10,8 +10,22 @@ export declare const MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
 /**
  * Build the essential-only configuration blob for an activity connector node.
  * DAP re-fetches optional data (fieldsContainer, caches) on open.
+ *
+ * `savedFilterTrees` is a map keyed by the connector's filter input
+ * parameter name (e.g. `"where"` for IS List All Records) and valued by
+ * the structured filter tree the user authored. The compiled CEQL string
+ * lives separately on `inputs.detail.queryParameters[<paramName>]`;
+ * persisting both halves keeps the activity round-trippable in Studio Web,
+ * which reads the tree to render the filter widget and re-derives the
+ * CEQL expression on save.
+ *
+ * `customFieldsRequestDetails` is the design-time inputs for a
+ * connector's "fetch custom fields" ObjectAction (e.g. Jira's GenerateSchema).
+ * The CLI does not validate ObjectAction existence or parameter coverage —
+ * the caller is responsible for supplying a payload that the runtime will
+ * accept.
  */
-export declare function buildActivityEssentialConfiguration(instanceParameters: Record<string, unknown>, methodInfo: ConnectorMethodInfo): Record<string, unknown>;
+export declare function buildActivityEssentialConfiguration(instanceParameters: Record<string, unknown>, methodInfo: ConnectorMethodInfo, savedFilterTrees?: Record<string, FilterTree> | null, customFieldsRequestDetails?: CustomFieldsRequestDetails | null): Record<string, unknown>;
 /**
  * Build the essential-only configuration blob for a managed HTTP node
  * (core.action.http.v2). The managed HTTP node always proxies through the
@@ -23,7 +37,10 @@ export declare function buildManagedHttpEssentialConfiguration(): Record<string,
  * Trigger essentials include filter (user-configured, not recoverable from connector)
  * but omit operation, httpMethod, path (not applicable to triggers).
  *
- * The `filter` tree is the design-time source of truth for the trigger's
- * conditions;
+ * The `filter` tree is the design-time source of truth for the user's filter
+ * conditions. The mandatory filter (from required event parameters) is NOT
+ * persisted in essentialConfiguration — it's computed fresh from event parameters
+ * and combined with the user filter expression at configure-time to produce
+ * detail.filterExpression.
  */
 export declare function buildTriggerEssentialConfiguration(instanceParameters: Record<string, unknown>, filter?: FilterTree | null): Record<string, unknown>;

package/dist/src/dap/filter-builder/field-metadata.d.ts

@@ -10,6 +10,13 @@ export type FilterFieldType = "string" | "number" | "integer" | "boolean" | "dat
 export type FilterFieldMetadata = {
     name: string;
     type: FilterFieldType;
+    /**
+     * Connector-side aliases for the field. When present, the CEQL compiler
+     * emits `searchableNames[0]` as the field identifier instead of `name`
+     * (Studio Web parity — some connectors expose a friendlier `name` but
+     * require the alias in the query string).
+     */
+    searchableNames?: readonly string[];
 };
 /** Result of building a filter: both the normalized tree and derived JMESPath. */
 export type BuiltFilter = {

package/dist/src/dap/filter-builder/index.d.ts

@@ -23,6 +23,11 @@ export { getUuid } from "./uuid.js";
 export { WorkflowValue } from "./workflow-value.js";
 import type { BuiltFilter, FilterFieldMetadata } from "./field-metadata.js";
 import type { FilterTree } from "./filter-tree.js";
+export type BuiltCeqlFilter = {
+    filter: FilterTree;
+    ceqlExpression: string;
+    isLiteral: boolean;
+};
 /**
  * Raised when the caller hands the builder a filter feature we haven't
  * ported yet (array fields, expression/non-literal values, enum arrays, etc.).
@@ -45,3 +50,13 @@ export declare function buildFilter(tree: FilterTree, fields: readonly FilterFie
  * Prefer `buildFilter` when the normalized tree is also needed.
  */
 export declare function buildFilterExpression(tree: FilterTree, fields: readonly FilterFieldMetadata[]): string;
+/**
+ * Build the paired `filter` tree and CEQL expression for an IS connector
+ * activity (List All Records and similar list/query operations).
+ *
+ * Parallel to {@link buildFilter} for triggers — same input shape, same
+ * normalization + field-existence checks; the only difference is the
+ * compiled output is a CEQL string (delegated to `CeqlHelper`, a verbatim
+ * port of Studio Web's `ceql-helper.ts`).
+ */
+export declare function buildCeqlFilter(tree: FilterTree, fields: readonly FilterFieldMetadata[]): BuiltCeqlFilter;

package/dist/src/dap/helpers/activity-configuration-extensions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Local shim for SW's `ActivityConfigurationExtensions` (mirrors
+ * `@sw/.../runtime/extensions/activity-configuration-extensions`). Only the
+ * `getMandatoryFilterFields` selector consumed by `mandatory-filter-builder`
+ * is ported; SW exposes additional helpers the CLI does not yet exercise.
+ */
+import type { ConfigurationField } from "./configuration-field.js";
+export declare class ActivityConfigurationExtensions {
+    /**
+     * Mirrors SW `getMandatoryFilterFields(activityConfiguration)`:
+     *
+     *   activityConfiguration.fieldsContainer.inputFields
+     *     .filter(f => f.fieldLocation !== Path && f.fieldLocation !== Query);
+     *
+     * The CLI lifts the input arg to a free `ConfigurationField[]` since the
+     * `TriggerActivityConfiguration` wrapper is not yet ported. Path/Query
+     * parameters are never mandatory filter sources because they shape the
+     * connector request URL, not the event subscription body.
+     */
+    static getMandatoryFilterFields(inputFields: readonly ConfigurationField[]): ConfigurationField[];
+}

package/dist/src/dap/helpers/clr-type-mock.d.ts

@@ -15,3 +15,7 @@ export declare class ClrTypeMock {
     constructor(name: string, isArray?: boolean);
     isSame(other: ClrTypeMock | string | null | undefined): boolean;
 }
+/**
+ * Map IS field type strings to ClrTypeMock instances for mandatory filter building.
+ */
+export declare function toClrType(rawType: string | undefined): ClrTypeMock;

package/dist/src/dap/helpers/configuration-field.d.ts

@@ -0,0 +1,25 @@
+import { ClrTypeMock } from "./clr-type-mock.js";
+import { FieldLocation } from "./field-location.js";
+/**
+ * Local shim for SW's `ConfigurationField` (mirrors
+ * `@sw/.../runtime/models/configuration-field`). SW's class carries the full
+ * activity-configuration field descriptor; this shim keeps the members the
+ * filter-builder + mandatory-filter helpers read (`name`, `id`, `clrType`,
+ * `mask`, `fieldLocation`).
+ *
+ * `id` is the **sanitized** field identifier (post `NamingHelper.getValidDesignPropertyName`,
+ * e.g. `ParentFolders[*].ID` → `ParentFolders_array_ID`). Mandatory-filter
+ * `FieldObject` lookups go through `id`, never `name` — see SW PR #18040.
+ *
+ * `fieldLocation` mirrors SW's `FieldLocation` enum and is consumed by
+ * `ActivityConfigurationExtensions.getMandatoryFilterFields`, which excludes
+ * `Path` and `Query` parameters from the mandatory-filter set.
+ */
+export declare class ConfigurationField {
+    readonly name: string;
+    readonly id: string;
+    readonly clrType: ClrTypeMock;
+    readonly mask: string | null;
+    readonly fieldLocation: FieldLocation;
+    constructor(name: string, clrType?: ClrTypeMock, mask?: string | null, id?: string, fieldLocation?: FieldLocation);
+}

package/dist/src/dap/helpers/field-location.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Local shim for SW's `FieldLocation` (mirrors
+ * `@sw/.../runtime/models/connector-metadata/field-location`). Used by
+ * `ActivityConfigurationExtensions.getMandatoryFilterFields` to filter
+ * inputFields to those located in the request body — path/query parameters
+ * are never mandatory filter sources.
+ */
+export declare const FieldLocation: {
+    readonly Body: "Body";
+    readonly Path: "Path";
+    readonly Query: "Query";
+    readonly Header: "Header";
+};
+export type FieldLocation = (typeof FieldLocation)[keyof typeof FieldLocation];

package/dist/src/dap/helpers/field-object-helpers.d.ts

@@ -0,0 +1,16 @@
+import type { FieldObject } from "./field-object.js";
+/**
+ * Local shim for SW's `FieldObjectHelpers` (mirrors
+ * `@sw/.../design-time/helpers/field-object-helpers`). Only the lookup helper
+ * used by mandatory-filter assembly is ported; SW carries additional helpers
+ * that the CLI does not yet exercise.
+ */
+export declare class FieldObjectHelpers {
+    /**
+     * Returns the first `FieldArgument` or `FieldLiteral` entry with `id ===
+     * fieldId`, or `undefined`. Lookup is by **sanitized** id only — callers
+     * passing `field.name` for array/dotted paths will miss (this is the bug
+     * fixed in SW PR #18040).
+     */
+    static getFieldArgumentOrLiteral(fieldObjects: readonly FieldObject[], fieldId: string): FieldObject | undefined;
+}

package/dist/src/dap/helpers/field-object-type.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Local shim for SW's `FieldObjectType` (mirrors
+ * `@sw/.../runtime/models/field-object-type`). Used by `FieldObjectHelpers` to
+ * filter mandatory-filter sources to argument or literal entries (resolved at
+ * design time) and skip expressions resolved at runtime.
+ */
+export declare const FieldObjectType: {
+    readonly FieldArgument: "FieldArgument";
+    readonly FieldLiteral: "FieldLiteral";
+    readonly FieldExpression: "FieldExpression";
+};
+export type FieldObjectType = (typeof FieldObjectType)[keyof typeof FieldObjectType];

package/dist/src/dap/helpers/field-object.d.ts

@@ -0,0 +1,18 @@
+import type { WorkflowValue } from "../filter-builder/workflow-value.js";
+import type { FieldObjectType } from "./field-object-type.js";
+/**
+ * Local shim for SW's `FieldObject` (mirrors
+ * `@sw/.../runtime/models/field-object`). Represents a single field entry on
+ * an activity's design-time state — keyed by the **sanitized** field id (post
+ * `NamingHelper.getValidDesignPropertyName`).
+ *
+ * Mandatory-filter assembly inspects `type` to keep `FieldArgument` /
+ * `FieldLiteral` entries (see SW PR #18040 — FieldLiteral was previously
+ * dropped) and reads `value.value` only when `value.isLiteral` is true.
+ */
+export declare class FieldObject {
+    readonly id: string;
+    readonly value: WorkflowValue | null;
+    readonly type: FieldObjectType;
+    constructor(id: string, value: WorkflowValue | null, type: FieldObjectType);
+}

package/dist/src/dap/helpers/field-type-helper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Local shim for SW's `FieldTypeHelper` (mirrors
+ * `@sw/.../runtime/helpers/field-type-helper`). Only the name-based array
+ * detection used by `JmesHelper.buildMandatoryFilterExpression` is ported.
+ */
+export declare class FieldTypeHelper {
+    /** Returns true when the field name carries the `[*]` array marker. */
+    static isArrayType(name: string): boolean;
+}

package/dist/src/dap/helpers/filter-builder/ceql-helper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Ported verbatim from Studio Web:
+ *   src/Client/app/packages/connector-activity/is-activities/runtime/helpers/filter-builder/ceql-helper.ts
+ *
+ * Only import paths are rewritten to point at local shims / models. Method
+ * bodies are kept identical to SW. The CLI filter-builder does not currently
+ * emit CEQL (the JMESPath path is used for triggers); this file is carried
+ * alongside for parity with SW so future CEQL work can reuse it.
+ */
+import { FilterGroupOperator } from "../../filter-builder/filter-group-operator.js";
+import { FilterOperator } from "../../filter-builder/filter-operator.js";
+import type { FilterTree } from "../../filter-builder/filter-tree.js";
+import { ClrTypeMock } from "../clr-type-mock.js";
+/**
+ * TEMP no-op shim for SW's `ConfigurationField`. The CEQL path is not yet
+ * used by the CLI filter-builder; this carries just the fields `ceql-helper`
+ * reads so the verbatim port compiles.
+ */
+export type ConfigurationField = {
+    id: string;
+    name: string;
+    clrType: ClrTypeMock;
+    enum?: unknown[];
+    searchableNames?: string[];
+    mask?: string | null;
+};
+export declare class CeqlHelper {
+    static readonly operatorMappings: Map<FilterOperator, string>;
+    static readonly functionMappings: Map<FilterOperator, string>;
+    static readonly logicalOperatorMappings: Map<FilterGroupOperator, string>;
+    static buildCeqlFilterExpression(filters: FilterTree, filterCriteria: ConfigurationField[]): {
+        ceqlExpression: string;
+        isLiteral: boolean;
+    };
+    private static _composeCeqlPathExpression;
+    private static _isStringValue;
+    private static _getCeqlValueFromEnumValue;
+    private static _composeSingleValueExpression;
+}

package/dist/src/dap/helpers/filter-builder/jmes-helper.d.ts

@@ -12,6 +12,7 @@ import { FilterOperator } from "../../filter-builder/filter-operator.js";
 import type { FilterTree } from "../../filter-builder/filter-tree.js";
 import type { WorkflowValue } from "../../filter-builder/workflow-value.js";
 import { ClrTypeMock } from "../clr-type-mock.js";
+import type { ConfigurationField } from "../configuration-field.js";
 import { EventField } from "../event-field.js";
 import { type TranslationConfiguration } from "../translation.js";
 /**
@@ -31,7 +32,36 @@ export declare class JmesHelper {
     static readonly operatorMappings: Map<FilterOperator, string>;
     static readonly functionMappings: Map<FilterOperator, string>;
     static readonly logicalOperatorMappings: Map<FilterGroupOperator, string>;
-    static buildMandatoryFilterExpression(fieldArguments: Map<string, unknown>): string;
+    /**
+     * Builds the mandatory filter JMES expression for trigger inputs that participate in event matching.
+     * Array-shaped fields (name contains `[*]`) are routed through {@link composeArrayJmesPathExpression}
+     * so curated event fields like `ParentFolders[*].ID` emit filter-projection syntax
+     * (`ParentFolders[?ID=='INBOX']`) instead of an invalid scalar comparison.
+     *
+     * Mandatory values may be non-literal (workflow expressions). Non-literal RHS is wrapped via
+     * {@link addExpressionWrapper} and embedded in JMES as a single-quoted string — same shape as
+     * {@link composeJmesPathExpression}. The returned `isLiteral` flag is `false` whenever any
+     * scalar entry is non-literal, so callers can decide whether to wrap the combined expression in
+     * a runtime template literal.
+     */
+    static buildMandatoryFilterExpression(fieldArguments: Map<ConfigurationField, WorkflowValue>, translationConfiguration?: TranslationConfiguration): {
+        jmesExpression: string;
+        isLiteral: boolean;
+    };
+    /**
+     * Format a literal scalar value as a JMES expression fragment.
+     * Boolean and numeric types use backtick-wrapped JSON literals so JMES compares against the
+     * underlying primitive; everything else falls back to single-quoted strings.
+     * DateTimeOffset is handled by callers that also rewrite the LHS with `to_number(...)`.
+     */
+    private static readonly _booleanType;
+    /**
+     * Format a literal scalar value as a JMES expression fragment.
+     * Boolean and numeric types use backtick-wrapped JSON literals so JMES compares against the
+     * underlying primitive; everything else falls back to single-quoted strings.
+     * DateTimeOffset is handled by callers that also rewrite the LHS with `to_number(...)`.
+     */
+    private static _formatLiteral;
     /** Convert the filter tree to JMES string */
     static buildFilterExpression(filters: FilterTree, filterCriteria: EventField[], translationConfiguration?: TranslationConfiguration, options?: BuildFilterExpressionOptions): {
         jmesExpression: string;

package/dist/src/dap/helpers/mandatory-filter-builder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Ported from Studio Web:
+ *   src/Client/app/packages/connector-activity/is-activities/design-time/view-models/connector-trigger-view-model.ts
+ *   `_setMandatoryFilterExpression()`
+ *
+ * SW's caller is an instance method on `ConnectorTriggerViewModel`; the CLI
+ * has no view-model layer, so the body is exposed as a free function with the
+ * inputs (`mandatoryFields`, `fieldObjects`) lifted to parameters. The lookup
+ * + literal-acceptance semantics are kept identical so future CLI callers
+ * inherit the SW PR #18040 fix.
+ */
+import type { ConfigurationField } from "./configuration-field.js";
+import type { FieldObject } from "./field-object.js";
+/**
+ * Build the trigger's mandatory-filter JMES expression, or `null` when no
+ * mandatory field resolves to a value.
+ *
+ * Mirrors SW `_setMandatoryFilterExpression` (post PR #18081):
+ *  - looks up `FieldObject` by sanitized `field.id` (not raw `field.name`);
+ *  - accepts `FieldArgument` and `FieldLiteral`, skips `FieldExpression`;
+ *  - passes `WorkflowValue` objects to `JmesHelper.buildMandatoryFilterExpression`,
+ *    which handles both literal values and workflow expressions.
+ */
+export declare function buildMandatoryFilterExpression(mandatoryFields: readonly ConfigurationField[], fieldObjects: readonly FieldObject[]): string | null;

package/dist/src/dap/helpers/translation.d.ts

@@ -1,11 +1,16 @@
 /**
- * TEMP no-op shims for SW translation utilities:
+ * Shims for SW translation utilities (ported for PR #18081 support):
  * - `TranslationConfiguration` from `@uipath/studio-web-unified-build`
  * - `addExpressionWrapper` from `@sw/translation/translators/utils-translators`
  *
- * The CLI filter-builder only emits literal-value expressions, so the
- * wrapper used by SW for non-literal (expression) values is never required.
- * Revisit if/when expression-value support is ported.
+ * Post PR #18081, the CLI filter-builder supports non-literal (workflow expression)
+ * values in mandatory filters, which require wrapping for runtime template literal
+ * substitution.
  */
 export type TranslationConfiguration = unknown;
+/**
+ * Wrap a workflow expression for runtime template literal evaluation.
+ * SW's real implementation uses translator-specific syntax; the CLI default
+ * matches SW's template-literal format: `${expression}`.
+ */
 export declare function addExpressionWrapper(value: string | undefined, _translationConfiguration?: TranslationConfiguration): string;

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

@@ -1,6 +1,14 @@
 export { buildActivityEssentialConfiguration, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_CONNECTOR_VERSION, } from "./essential-config.js";
 export * from "./filter-builder/index.js";
-export { buildInputMetadata, extractMultipartParameters, } from "./input-metadata.js";
-export type { ConnectorMethodInfo, FieldReference, InputMetadata, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, MultipartParam, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./types.js";
+export { ActivityConfigurationExtensions } from "./helpers/activity-configuration-extensions.js";
+export { ClrTypeMock, toClrType } from "./helpers/clr-type-mock.js";
+export { ConfigurationField } from "./helpers/configuration-field.js";
+export { FieldLocation } from "./helpers/field-location.js";
+export { FieldObject } from "./helpers/field-object.js";
+export { FieldObjectHelpers } from "./helpers/field-object-helpers.js";
+export { FieldObjectType } from "./helpers/field-object-type.js";
+export { buildMandatoryFilterExpression } from "./helpers/mandatory-filter-builder.js";
+export { buildInputMetadata, extractMultipartParameters, inlineMultipartFileValues, } from "./input-metadata.js";
+export type { ConnectorMethodInfo, CustomFieldsRequestDetails, FieldDesign, FieldReference, InputMetadata, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, MultipartParam, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./types.js";
 export type { ConnectorValidationContext, Issue, IssueType, ValidationRule, } from "./validation/index.js";
-export { DEFAULT_RULES, validateConfiguration, validateConnectionId, validateEndpoint, validateEventMode, validateEventType, validateFolderKey, validateHttpMethod, validateIntSvcNode, validateMethodInMetadata, validateObjectName, validatePathTemplateParams, validateRequiredEventParameters, validateRequiredFields, validateRequiredParameters, } 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/input-metadata.d.ts

@@ -3,11 +3,40 @@ import type { InputMetadata, ISMetadataParam, MultipartParam } from "./types.js"
  * Extract multipart parameters from IS metadata parameters.
  * These are fields with type "multipart" (e.g. file attachments).
  *
- * TODO: file-type multipart params can carry a `value` binding
- * (e.g. "=js:($vars.start.output.fileToAdd)") for attachments.
- * Currently not supported — cli debug may not support file params either.
+ * Returns declarations only (`name`, `dataType`). File-typed entries can
+ * carry an inline `value` binding (`=js:$vars.x.output`) per Studio Web's
+ * on-wire shape — populate it with `inlineMultipartFileValues` after this
+ * call.
  */
 export declare function extractMultipartParameters(params: ISMetadataParam[]): MultipartParam[];
+/**
+ * Move file-typed multipart values from `bodyParameters` into the matching
+ * multipart entry's inline `value` slot, matching Studio Web's on-wire shape.
+ *
+ * Background: flow-workbench's BPMN emitter
+ * (`packages/services/src/serialization/uipath-extension.ts`
+ * `convertMultipartParametersToInputs`) reads `param.value` from each
+ * `multipartParameters[i]` entry where `dataType === "file"`. Values left in
+ * `bodyParameters` are not emitted as BPMN file inputs and are lost on
+ * round-trip. This helper aligns CLI-authored `.flow` files with that shape.
+ *
+ * Rules:
+ * - For each `multipartParams` entry with `dataType === "file"`, if
+ *   `bodyParameters[name]` is a string, move it to the entry's `.value` slot
+ *   and delete the key from the returned `bodyParameters`.
+ * - String-typed multipart entries are left untouched — the body aggregator
+ *   keeps its content in `bodyParameters[bodyFieldName]` (Studio Web's BPMN
+ *   emitter reads it from there regardless).
+ * - Non-string `bodyParameters` values (objects, unexpected shapes) are left
+ *   in place so callers can detect and handle them.
+ * - Returns new array / object — does not mutate inputs. Returns
+ *   `bodyParameters: undefined` when the cleaned object is empty so callers
+ *   can drop the bucket cleanly.
+ */
+export declare function inlineMultipartFileValues(multipartParams: MultipartParam[], bodyParameters: Record<string, unknown> | undefined): {
+    multipartParams: MultipartParam[];
+    bodyParameters: Record<string, unknown> | undefined;
+};
 /**
  * Build inputMetadata from multipart params and operation type.
  *

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

@@ -5,6 +5,18 @@
  * and are used by essential configuration builders across multiple tools
  * (flow-tool, case-tool, coded-apps, etc.).
  */
+/**
+ * Design-time hints for a field or parameter.
+ *
+ * The only consumer right now is the CEQL filter builder, which looks for
+ * a parameter with `component === "FilterBuilder"` to decide where the
+ * compiled CEQL string should land in `queryParameters`. The parameter
+ * name is connector-specific (often `where`, but not always — Salesforce
+ * uses `q`, some connectors use `filter`, etc.).
+ */
+export type FieldDesign = {
+    component?: string;
+};
 export type ISMetadataParam = {
     name: string;
     description: string;
@@ -16,10 +28,12 @@ export type ISMetadataParam = {
     displayName: string;
     reference?: Record<string, unknown>;
     defaultValue?: unknown;
+    design?: FieldDesign;
 };
 export type MultipartParam = {
     name: string;
     dataType: string;
+    value?: string;
 };
 export type InputMetadata = {
     type?: string;
@@ -65,6 +79,21 @@ export type ISField = {
     method: Record<string, ISFieldMethod>;
     enum?: unknown[];
     reference?: FieldReference;
+    /** Field is filterable in CEQL queries (List All Records and similar). */
+    searchable?: boolean;
+    /**
+     * Operators (CEQL tokens) the connector permits for this field.
+     * Empty / undefined means the connector did not constrain the operator set.
+     */
+    searchableOperators?: string[];
+    /**
+     * Alternative names the connector accepts for this field in CEQL. The
+     * filter compiler emits `searchableNames[0]` when present, falling back
+     * to `name` otherwise. Some connectors expose user-friendly display
+     * names but require a different identifier in the query string.
+     */
+    searchableNames?: string[];
+    design?: FieldDesign;
 };
 export type ISMetadata = {
     fields?: Record<string, ISField> | ISField[];
@@ -103,3 +132,14 @@ export type TriggerObjectMetadata = {
     custom: string;
     fields: Record<string, TriggerField>;
 };
+/**
+ * Design-time inputs for a connector's "fetch custom fields" ObjectAction.
+ * Mirrors the shape Studio Web's TS port emits (camelCase keys, parameterValues
+ * as an array of [key, value] tuples — see Solution 386 / Jira Create Issue
+ * empirical sample). The runtime replays the ObjectAction on each invocation
+ * with these values to fetch the connector-specific custom fields schema.
+ */
+export type CustomFieldsRequestDetails = {
+    objectActionName: string;
+    parameterValues: Array<[string, string | null]>;
+};

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

@@ -1,4 +1,4 @@
-export { validateConfiguration, validateConnectionId, validateEndpoint, validateEventMode, validateEventType, validateFolderKey, validateHttpMethod, validateMethodInMetadata, validateObjectName, validatePathTemplateParams, validateRequiredEventParameters, validateRequiredFields, validateRequiredParameters, } from "./rules.js";
+export { METHOD_TO_OPERATION, normalizeHttpMethod, OPERATION_TO_METHOD, validateConfiguration, validateConnectionId, validateEndpoint, validateEventMode, validateEventType, validateFolderKey, validateHttpMethod, validateMethodInMetadata, validateMethodMatchesOperation, validateObjectName, validatePathTemplateParams, validateRequiredEventParameters, validateRequiredFields, validateRequiredParameters, } from "./rules.js";
 export type { ConnectorValidationContext, Issue, IssueType, ValidationRule, } from "./types.js";
 import type { ConnectorValidationContext, Issue, ValidationRule } from "./types.js";
 /**

package/dist/src/dap/validation/rules.d.ts

@@ -3,8 +3,45 @@ import type { ConnectorValidationContext, Issue } from "./types.js";
 export declare function validateConnectionId(context: ConnectorValidationContext): Issue[];
 /** FolderKey must be present and non-empty. */
 export declare function validateFolderKey(context: ConnectorValidationContext): Issue[];
+/**
+ * IS-side method label → operation name (e.g. `"GETBYID" → "Retrieve"`).
+ * Authoritative source for the IS method lexicon. Use {@link normalizeHttpMethod}
+ * to convert these labels to standard HTTP verbs before serializing to a flow.
+ */
+export declare const METHOD_TO_OPERATION: Record<string, string>;
+/**
+ * Operation name → IS-side method label (e.g. `"RETRIEVE" → "GETBYID"`).
+ * Keys are uppercased; both operation names ("LIST", "RETRIEVE", …) and HTTP
+ * verbs ("GET", "POST", …) are accepted as input for tolerant lookup.
+ */
+export declare const OPERATION_TO_METHOD: Record<string, string>;
+/**
+ * Normalize an IS-side method label to a standard HTTP verb.
+ *
+ * IS metadata synthesizes `"GETBYID"` for path-parameterized retrieve
+ * operations — the only non-HTTP-verb in the IS method lexicon (see
+ * {@link METHOD_TO_OPERATION}). The .flow validator and BPMN runtime expect
+ * standard HTTP verbs only; call this before serializing to
+ * `inputs.detail.method`.
+ *
+ * Method-map lookups against the IS metadata must keep the original label —
+ * `methodMap["GETBYID"]` and `methodMap["GET"]` resolve to different
+ * operations on connectors that expose both List and Retrieve.
+ */
+export declare function normalizeHttpMethod(rawMethod: string): string;
 /** Activity nodes must have a valid HTTP method.  Maps to DAP-RT-1100. */
 export declare function validateHttpMethod(context: ConnectorValidationContext): Issue[];
+/**
+ * Cross-validate `httpMethod` against the operation declared in the
+ * configuration blob's `essentialConfiguration.instanceParameters.operation`.
+ *
+ * Catches typos and copy-paste errors at configure time (e.g. `method: "POST"`
+ * on a Retrieve activity). Skips when configuration is missing/malformed,
+ * httpMethod is missing, or instanceParameters.operation is absent — those
+ * cases are caught by other rules. Maps operations to expected HTTP verbs via
+ * {@link OPERATION_TO_METHOD} + {@link normalizeHttpMethod}.
+ */
+export declare function validateMethodMatchesOperation(context: ConnectorValidationContext): Issue[];
 /** Activity nodes must have an endpoint starting with "/". */
 export declare function validateEndpoint(context: ConnectorValidationContext): Issue[];
 /** ObjectName must be present for both activities and triggers.  Maps to DAP-RT-1053. */
@@ -16,6 +53,12 @@ export declare function validateEventType(context: ConnectorValidationContext):
 /**
  * Configuration blob must exist and be parseable JSON
  * with an essentialConfiguration envelope.  Maps to DAP-RT-1000.
+ *
+ * Error titles include a one-line shape hint so agents and humans see what
+ * the validator expects without consulting external docs. Eval runs prior
+ * to this hint showed agents looping 3-4 times on bare "Configuration is
+ * missing or empty." before discovering the `=jsonString:{essentialConfiguration:{...}}`
+ * envelope.
  */
 export declare function validateConfiguration(context: ConnectorValidationContext): Issue[];
 /**

package/dist/src/index.d.ts

@@ -2,5 +2,5 @@ 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 ExecuteOperationResult, executeOperation, folderOverride, getEventObjectMetadataAsSchema, getInstanceEventObjectMetadataAsSchema, getInstanceObjectMetadataAsSchema, getObjectMetadataAsSchema, } from "./client-factory.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 * from "./dap/index.js";

package/dist/src/user-agent.d.ts

@@ -0,0 +1 @@
+export declare const SDK_USER_AGENT: string;