@uipath/integrationservice-sdk 1.199.0 → 1.201.0-preview.115

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

@@ -0,0 +1 @@
+export declare function normalizeConnectionStatus(status: unknown): string;

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

@@ -1,4 +1,4 @@
-import type { FilterTree } from "./filter-builder/filter-tree.js";
+import type { DesignTimeFilterTree, IDesignTimeActivityClient } from "@uipath/integration-service-design-time";
 import type { ConnectorMethodInfo, CustomFieldsRequestDetails } from "./types.js";
 /**
  * Connector key and version for the managed HTTP node (core.action.http.v2).
@@ -8,39 +8,75 @@ import type { ConnectorMethodInfo, CustomFieldsRequestDetails } from "./types.js
 export declare const MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
 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.
+ * Build the OFFLINE (no-fetch) essential-only configuration blob for an activity connector node from
+ * the caller-supplied identity + `methodInfo`. `connectorVersion` and the connector's real fields are
+ * not available this way (left null); for a blob derived from the connector's own metadata, drive a
+ * live client via {@link createConfiguredActivityClient} and read `getEssentialConfiguration()` off it.
  *
- * `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.
+ * `savedFilterTrees` is a map keyed by the connector's filter input parameter name (e.g. `"where"`)
+ * 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.
  *
- * `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.
+ * `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 supplies a payload the runtime will accept.
  */
-export declare function buildActivityEssentialConfiguration(instanceParameters: Record<string, unknown>, methodInfo: ConnectorMethodInfo, savedFilterTrees?: Record<string, FilterTree> | null, customFieldsRequestDetails?: CustomFieldsRequestDetails | null): Record<string, unknown>;
+export declare function buildActivityEssentialConfiguration(instanceParameters: Record<string, unknown>, methodInfo: ConnectorMethodInfo, savedFilterTrees?: Record<string, DesignTimeFilterTree> | null, customFieldsRequestDetails?: CustomFieldsRequestDetails | null): Record<string, unknown>;
+/**
+ * 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
+ * bearer via {@link createLiveConnectionsProvider} — so the returned client exposes the connector's
+ * real operation, HTTP method, path, version, and field set instead of hand-derived values. The
+ * caller's authored data is produced by the activity itself rather than overlaid afterwards:
+ *   - `customFieldsRequestDetails` is replayed as property edits so the connector's custom-fields
+ *     request (e.g. Jira's GenerateSchema) fires and the activity caches the result.
+ *   - `savedFilterTrees` is applied as a filter-builder edit so the activity derives the saved tree
+ *     itself, instead of re-implementing the connector's filter logic here. The map is keyed by the
+ *     property that receives each tree — the connector's filter parameter for an activity (e.g. `where`),
+ *     or `filter` for a trigger node (the underlying activity routes its subtype from `instanceParameters`,
+ *     so triggers reuse this same client; the output blob then carries `filter` instead of `savedFilterTrees`).
+ *     Trees containing a dynamic operand (`isLiteral: false`) are rejected with `FilterNotSupportedError`
+ *     before any fetch — the client compiles them into an unresolvable embedded expression (MST-13005).
+ *     Run each tree through `substituteFilterVariables` first to author a dynamic filter, then hand the
+ *     authored tree back with {@link applySavedFilterTree} once the compiled expression has been read.
+ *   - `fieldValues` is the flat `{ field: value }` map of regular field values (body / query / path, or a
+ *     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.
+ *
+ * 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
+ * essential configuration to {@link assertActivityMetadataResolved} to check the connection resolved
+ * (a stale token or disabled connection leaves the configuration without a connector version).
+ *
+ * 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>;
+/**
+ * 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
+ * different tree after construction. The filter-variable path (MST-13005) needs both trees in turn:
+ * the client is built with the placeholder tree so it compiles a runtime-resolvable expression, then
+ * the AUTHORED tree is applied here so the essential configuration the caller persists carries the
+ * author's real expressions for Studio Web's filter widget.
+ */
+export declare function applySavedFilterTree(client: IDesignTimeActivityClient, propertyName: string, tree: DesignTimeFilterTree): Promise<void>;
+/**
+ * Guard: throw if the activity's essential configuration was not resolved from connector metadata
+ * (no `connectorVersion`) — e.g. a stale token or disabled connection. Call it on the configuration
+ * read off a {@link createConfiguredActivityClient} client.
+ */
+export declare function assertActivityMetadataResolved(essentialConfiguration: Record<string, unknown>, connectionId: string): void;
 /**
  * Build the essential-only configuration blob for a managed HTTP node
  * (core.action.http.v2). The managed HTTP node always proxies through the
  * uipath-uipath-http connector with a fixed POST /http-request shape.
  */
 export declare function buildManagedHttpEssentialConfiguration(): Record<string, unknown>;
-/**
- * Build the essential-only configuration blob for a trigger connector node.
- * 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 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

@@ -1,25 +1,9 @@
-import type { FilterTree } from "./filter-tree.js";
 /**
- * Event field metadata needed to serialize a filter to JMESPath.
+ * Primitive type kinds the design-time package understands for a filter field.
  *
- * Only carries what the generator needs (name + primitive type kind). The
- * caller extracts this from `TriggerObjectMetadata.fields` before invoking
- * {@link buildFilter}.
+ * The CLI no longer compiles filters itself — the published
+ * `@uipath/integration-service-design-time` client owns that now — but callers
+ * still map raw IS metadata field types into this union when classifying a
+ * saved filter tree's fields, so it stays on the SDK surface.
  */
 export type FilterFieldType = "string" | "number" | "integer" | "boolean" | "date-time";
-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 = {
-    filter: FilterTree;
-    filterExpression: string;
-};

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

@@ -1,62 +1,56 @@
 /**
- * IS trigger filter builder — produces the paired `filter` tree and
- * derived `filterExpression` that Studio Web and the Maestro runtime consume.
+ * Filter field typing helpers.
  *
- * The model files in this folder mirror Studio Web's
- * `connector-activity/is-activities/runtime/models/filter-builder` 1:1, and
- * the actual JMESPath generation is delegated to `JmesHelper` under
- * `../helpers/filter-builder/jmes-helper.ts` (also a verbatim port of SW).
- *
- * Studio Web generates the JMESPath `filterExpression` from the structured
- * `filter` tree; it cannot parse an expression back into the tree. Before
- * MST-8802, the CLI wrote only `filterExpression` and left `filter: null`,
- * which caused SW to show an empty filter UI and silently drop the user's
- * configuration on save. The CLI must now accept the filter tree as input
- * and emit both fields in lockstep.
- */
-export type { BuiltFilter, FilterFieldMetadata, FilterFieldType, } from "./field-metadata.js";
-export { Filter } from "./filter.js";
-export { FilterGroupOperator } from "./filter-group-operator.js";
-export { FilterOperator } from "./filter-operator.js";
-export { FilterTree } from "./filter-tree.js";
-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.).
- * Kept as a distinct error type so callers can surface a clear message rather
- * than seeing a raw `InvalidOperationException` / `ArgumentNullException`
- * bubble out from the SW helpers.
+ * The structured filter tree and its JMESPath/CEQL compilation now live in the
+ * published `@uipath/integration-service-design-time` client — the CLI only
+ * threads a saved tree through and reads the compiled expression back. What
+ * remains here is the `FilterFieldType` union callers use to classify raw IS
+ * metadata field types, plus the filter-variable substitution and the guard the
+ * compiled path runs behind. See MST-8802 / MST-13005.
  */
+import type { DesignTimeFilterTree } from "@uipath/integration-service-design-time";
+export type { FilterFieldType } from "./field-metadata.js";
 export declare class FilterNotSupportedError extends Error {
     constructor(message: string);
 }
 /**
- * Build the paired `filter` tree and `filterExpression` for an IS trigger.
+ * Guard a filter tree on its way to the compiled filter path. Throws
+ * {@link FilterNotSupportedError} for any condition (including nested groups)
+ * whose value is a dynamic operand (`isLiteral: false`); literal values pass.
  *
- * Generation is delegated to `JmesHelper.buildFilterExpression` (verbatim SW
- * port) so the CLI's expression output stays byte-identical to SW's.
+ * A tree returned by {@link substituteFilterVariables} always passes — every
+ * dynamic operand has become a `{var_<hash>}` literal placeholder.
  */
-export declare function buildFilter(tree: FilterTree, fields: readonly FilterFieldMetadata[]): BuiltFilter;
-/**
- * Back-compat helper for callers that only need the expression string.
- * Prefer `buildFilter` when the normalized tree is also needed.
- */
-export declare function buildFilterExpression(tree: FilterTree, fields: readonly FilterFieldMetadata[]): string;
+export declare function assertFilterTreeSupported(tree: DesignTimeFilterTree): void;
+/** Result of {@link substituteFilterVariables}. */
+export interface SubstitutedFilterTree {
+    /**
+     * Compile-ready copy of the authored tree: every dynamic operand replaced
+     * by its `{var_<hash>}` placeholder, so the compiler emits a plain literal
+     * where the runtime later substitutes the resolved value.
+     */
+    tree: DesignTimeFilterTree;
+    /**
+     * `var_<hash>` → whole-value `=js:` expression. Persisted as the sidecar
+     * the runtime resolves each placeholder from; empty when the authored tree
+     * holds no dynamic operand.
+     */
+    variables: Record<string, string>;
+}
 /**
- * Build the paired `filter` tree and CEQL expression for an IS connector
- * activity (List All Records and similar list/query operations).
+ * Split an authored filter tree into the tree the design-time client should
+ * compile and the filter-variable sidecar the runtime resolves — the contract
+ * Studio Web has shipped since it allowed dynamic filter operands (MST-13005).
+ *
+ * Each condition whose value is a dynamic operand (`isLiteral: false`) becomes
+ * a literal `{var_<hash>}` placeholder, and its expression is collected under
+ * that key as a whole-value `=js:` string. Identical expressions share one
+ * placeholder. The authored tree is not mutated — persist it as-is so Studio
+ * Web re-renders the filter widget with the author's real expressions.
  *
- * 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`).
+ * Throws {@link FilterNotSupportedError} for a dynamic operand carrying no
+ * expression, or one whose value is not a string: there is nothing to resolve,
+ * and compiling it yields an unresolvable expression the connector receives as
+ * literal text.
  */
-export declare function buildCeqlFilter(tree: FilterTree, fields: readonly FilterFieldMetadata[]): BuiltCeqlFilter;
+export declare function substituteFilterVariables(tree: DesignTimeFilterTree): SubstitutedFilterTree;

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

@@ -1,13 +1,5 @@
-export { buildActivityEssentialConfiguration, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_CONNECTOR_VERSION, } from "./essential-config.js";
+export { applySavedFilterTree, assertActivityMetadataResolved, buildActivityEssentialConfiguration, buildManagedHttpEssentialConfiguration, createConfiguredActivityClient, MANAGED_HTTP_CONNECTOR_KEY, MANAGED_HTTP_CONNECTOR_VERSION, } from "./essential-config.js";
 export * from "./filter-builder/index.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";

package/dist/src/dap/input-metadata.d.ts

@@ -45,6 +45,10 @@ export declare function inlineMultipartFileValues(multipartParams: MultipartPara
  * default 1000 cap.  StudioWeb resolves this from
  * `objectMethod.Pagination.MaxPageSize ?? connectorConfigurations.GetMaxPageSize()`.
  *
+ * `expressionResolutionFields` names the FilterBuilder parameters whose compiled value carries
+ * `{var_…}` placeholders. Studio Web derives it from the stored `fieldsContainer`, which the CLI does
+ * not persist, so callers pass the names they substituted (MST-13005).
+ *
  * Returns undefined when there's nothing to report.
  */
-export declare function buildInputMetadata(multipartParams: MultipartParam[], operation: string, maxPageSize?: number): InputMetadata | undefined;
+export declare function buildInputMetadata(multipartParams: MultipartParam[], operation: string, maxPageSize?: number, expressionResolutionFields?: string[]): InputMetadata | undefined;

package/dist/src/dap/live-connection-provider.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectorConnectionsProvider } from "@uipath/integration-service-design-time";
+/**
+ * Build a {@link ConnectorConnectionsProvider} backed by the logged-in CLI session. Pass it to the
+ * activity client so `updateConnection(connectionId)` performs the real metadata fetch.
+ *
+ * `getConnectionInfo` re-reads `getAuthContext` per call so the bearer is always fresh (a stale token
+ * 401s on every Integration Service endpoint). `elementInstanceId` is set to the connection id itself
+ * so the package's `instances/{id}/…` URL matches the CLI's `instances/{connectionId}/…` — Integration
+ * Service resolves it server-side.
+ */
+export declare function createLiveConnectionsProvider(): ConnectorConnectionsProvider;

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

@@ -44,6 +44,13 @@ export type InputMetadata = {
     pagination?: {
         maxPageSize: number;
     };
+    /**
+     * Names of the FilterBuilder parameters whose value carries `{var_…}`
+     * placeholders resolved from `inputs.detail.filterVariables`. The BPMN
+     * serializer only pairs a filter with its variables for the parameters
+     * listed here (MST-13005).
+     */
+    expressionResolutionFields?: string[];
 };
 export type ConnectorMethodInfo = {
     operation: string;

package/dist/src/index.d.ts

@@ -1,9 +1,11 @@
 import "./user-agent.js";
+export type { DesignTimeFilterTree } from "@uipath/integration-service-design-time";
 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 ConnectorSummary, type CreateApiClientOptions, createApiClient, createConnectionsConfig, createDesignConnector, createElementsConfig, type DesignConnectorRef, type EventOperationObject, type ExecuteOperationResult, executeOperation, exportConnectorZip, findDesignConnectorByKey, folderOverride, getConnectorById, getEventObjectMetadataAsSchema, getEventOperationObjects, getHttpRequestPreview, getInstanceEventObjectMetadataAsSchema, getInstanceObjectMetadataAsSchema, getObjectMetadataAsSchema, getPublishStatus, getValidatedAuthContext, getWebhookConfig, type HttpRequestPreviewResult, type ImportedConnector, type InstanceDesignActionResult, importConnectorZip, listConnectors, type PersistedConnector, type PublishConnectorArgs, type PublishJobResult, type PublishStatusResult, publishConnector, runInstanceDesignAction, updateDesignConnector, type WebhookConfigResult, } from "./client-factory.js";
+export { normalizeConnectionStatus } from "./connection-state.js";
 export * from "./dap/index.js";
 export { decodeElementsNextPageToken, ELEMENTS_NEXT_PAGE_DONE, type ElementsNextPage, hasMoreElementsPages, } from "./pagination.js";
 export { SDK_USER_AGENT } from "./user-agent.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/integrationservice-sdk",
   "license": "MIT",
-  "version": "1.199.0",
+  "version": "1.201.0-preview.115",
   "repository": {
     "type": "git",
     "url": "https://github.com/UiPath/cli.git",
@@ -27,5 +27,8 @@
   "files": [
     "dist"
   ],
-  "gitHead": "723e6801b77b5926ba75e75b6a756cc38b1b7adc"
+  "dependencies": {
+    "@uipath/integration-service-design-time": "0.19.3"
+  },
+  "gitHead": "f1086b73654d7728cb71f280588b3e0c77d535fc"
 }

package/dist/src/dap/filter-builder/filter-group-operator.d.ts

@@ -1,4 +0,0 @@
-export declare enum FilterGroupOperator {
-    And = 0,
-    Or = 1
-}

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

@@ -1,32 +0,0 @@
-export declare enum FilterOperator {
-    Equals = "Equals",
-    NotEquals = "NotEquals",
-    LessThan = "LessThan",
-    LessThanOrEqual = "LessThanOrEqual",
-    GreaterThan = "GreaterThan",
-    GreaterThanOrEqual = "GreaterThanOrEqual",
-    Contains = "Contains",
-    NotContains = "NotContains",
-    IsOneOf = "IsOneOf",
-    IsNotOneOf = "IsNotOneOf",
-    StartsWith = "StartsWith",
-    NotStartsWith = "NotStartsWith",
-    EndsWith = "EndsWith",
-    NotEndsWith = "NotEndsWith",
-    IsEmpty = "IsEmpty",
-    IsNotEmpty = "IsNotEmpty",
-    Is = "Is",
-    IsNot = "IsNot",
-    DateTimeEquals = "DateTimeEquals",
-    DateTimeNotEqual = "DateTimeNotEqual",
-    After = "After",
-    AfterOrEqual = "AfterOrEqual",
-    Before = "Before",
-    BeforeOrEqual = "BeforeOrEqual",
-    In = "In",
-    NotIn = "NotIn",
-    NotLike = "NotLike",
-    Like = "Like",
-    IsNotNull = "IsNotNull",
-    IsNull = "IsNull"
-}

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

@@ -1,12 +0,0 @@
-import { Filter } from "./filter.js";
-import type { FilterGroupOperator } from "./filter-group-operator.js";
-export declare class FilterTree {
-    constructor(groupOperator: FilterGroupOperator | null, index: number, filters: Filter[], uuId: string | null);
-    readonly groupOperator: FilterGroupOperator | null;
-    readonly index: number;
-    readonly uuId: string | null;
-    readonly filters: Filter[];
-    readonly groups: FilterTree[];
-    static factory(serialized: string): FilterTree;
-    private static _reviver;
-}

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

@@ -1,11 +0,0 @@
-import type { FilterOperator } from "./filter-operator.js";
-import { WorkflowValue } from "./workflow-value.js";
-export declare class Filter {
-    constructor(id: string, operator: FilterOperator | null, value: WorkflowValue | null, uiId: string | null);
-    readonly id: string;
-    readonly uiId: string | null;
-    readonly operator: FilterOperator | null;
-    value: WorkflowValue | null;
-    static factory(serialized: string): Filter;
-    private static _reviver;
-}

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

@@ -1,8 +0,0 @@
-/**
- * Generate a UUID for filter tree group/leaf identifiers.
- *
- * Ported verbatim from Studio Web's `getUuid` helper to keep SW and CLI in
- * sync — prefer the platform `crypto.randomUUID()` when available, fall back
- * to the `uuid` package otherwise.
- */
-export declare function getUuid(): string;

package/dist/src/dap/filter-builder/workflow-value.d.ts

@@ -1,9 +0,0 @@
-export declare class WorkflowValue {
-    isLiteral: boolean;
-    readonly rawString: string | null;
-    value: unknown | null;
-    constructor(value: unknown | null);
-    constructor(value: unknown | null, isLiteral: boolean);
-    static factory(serialized: string): WorkflowValue;
-    static canBeWorkflowValue(obj: unknown): boolean;
-}

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

@@ -1,21 +0,0 @@
-/**
- * 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/array-extensions.d.ts

@@ -1,8 +0,0 @@
-/**
- * Local shim for SW's `ArrayExtensions`. Mirrors
- * `@sw/.../extension-methods/array-extensions` — only the members the
- * filter-builder helpers use.
- */
-export declare class ArrayExtensions {
-    static any<T>(arr: readonly T[] | null | undefined): boolean;
-}

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

@@ -1,21 +0,0 @@
-/**
- * NO-OP
- */
-export declare class ClrTypeMock {
-    static readonly Int = "Int";
-    static readonly Long = "Long";
-    static readonly Double = "Double";
-    static readonly Float = "Float";
-    static readonly Boolean = "Boolean";
-    static readonly String = "String";
-    static readonly DateTimeOffset = "DateTimeOffset";
-    static readonly Enum: ClrTypeMock;
-    readonly name: string;
-    readonly isArray: boolean;
-    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

@@ -1,25 +0,0 @@
-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/constants.d.ts

@@ -1,9 +0,0 @@
-/**
- * Local shim for SW's runtime-helpers `Constants`. Mirrors
- * `@sw/.../runtime/helpers/constants`. Only carries the two markers the
- * filter-builder helpers use.
- */
-export declare class Constants {
-    static readonly FieldArrayMarker = "[*]";
-    static readonly ChunkSeparator = ".";
-}

package/dist/src/dap/helpers/enum-item.d.ts

@@ -1,10 +0,0 @@
-/**
- * TEMP no-op shim for SW's `EnumItem` (mirrors
- * `@sw/.../runtime/models/enum-item`). The CLI filter-builder does not author
- * enum-typed fields, so this carries only the `value` slot the helpers dereference.
- * Revisit if/when enum filter support is ported.
- */
-export declare class EnumItem {
-    readonly value: unknown;
-    constructor(value: unknown);
-}

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

@@ -1,20 +0,0 @@
-import { ClrTypeMock } from "./clr-type-mock.js";
-/**
- * Local shim for SW's `EventField` (mirrors
- * `@sw/.../runtime/models/connector-metadata/event-field`). SW's class carries
- * a richer connector-metadata descriptor; this shim keeps the members the
- * filter-builder helpers read (`name`, `clrType`, `type`, `mask`).
- */
-export declare class EventField {
-    readonly name: string;
-    readonly clrType: ClrTypeMock;
-    readonly type?: string;
-    readonly mask: string | null;
-    constructor(name: string, clrType: ClrTypeMock, type?: string, mask?: string | null);
-    /**
-     * TEMP no-op: SW synthesizes a string-typed event-field for connectors with
-     * `hasStaticLeftOperandFilterBuilder` (freeform left-operand). The CLI does
-     * not author freeform filters yet, so this returns a plain string field.
-     */
-    static createFreeform(name: string): EventField;
-}

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

@@ -1,11 +0,0 @@
-/**
- * Local shim for SW's old-infra exception classes. Mirrors
- * `@sw/.../old-infra/invalid-operation-exception` and
- * `@sw/.../old-infra/argument-null-exception`.
- */
-export declare class InvalidOperationException extends Error {
-    constructor(message: string);
-}
-export declare class ArgumentNullException extends Error {
-    constructor(message: string);
-}

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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-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

@@ -1,12 +0,0 @@
-/**
- * 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];