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

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

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

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

@@ -1,39 +0,0 @@
-/**
- * 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/filter-helper.d.ts

@@ -1,19 +0,0 @@
-/**
- * Ported verbatim from Studio Web:
- *   src/Client/app/packages/connector-activity/is-activities/runtime/helpers/filter-builder/filter-helper.ts
- *
- * Only the import paths have been rewritten to point at local shims under
- * `./` — the method bodies are intentionally kept identical so the CLI and
- * SW stay in sync. TEMP no-ops are annotated inline.
- */
-import type { FilterGroupOperator } from "../../filter-builder/filter-group-operator.js";
-import type { WorkflowValue } from "../../filter-builder/workflow-value.js";
-import { ClrTypeMock } from "../clr-type-mock.js";
-export declare class FilterHelper {
-    static supportsNumericFilter(type: ClrTypeMock): boolean;
-    static serializeDateTimeOffset(value: unknown | null, _mask: string | null): string;
-    static aggregateExpressions(expressions: string[], op: FilterGroupOperator, transformer: (input: string) => string, isGroup: boolean, logicalOperators: Map<FilterGroupOperator, string>): string;
-    static resolveValuesCollection(value: WorkflowValue | null): unknown[];
-    static convertCollectionToStringExpression(values: unknown[], quoteType?: string): string;
-    static convertValueToStringExpression(value: unknown, quoteType?: string): string | null;
-}

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

@@ -1,98 +0,0 @@
-/**
- * Ported verbatim from Studio Web:
- *   src/Client/app/packages/connector-activity/is-activities/runtime/helpers/filter-builder/jmes-helper.ts
- *
- * Only import paths are rewritten to local shims / models. Method bodies are
- * kept identical to SW so the two implementations produce byte-identical
- * JMESPath output. TEMP no-ops are annotated inline in their respective shims
- * (`addExpressionWrapper`, `FilterHelper.serializeDateTimeOffset`, `EventField.createFreeform`).
- */
-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 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";
-/**
- * Options controlling how {@link JmesHelper.buildFilterExpression} handles filter rows whose
- * field name is not present in the supplied event-field schema.
- */
-type BuildFilterExpressionOptions = {
-    /**
-     * When true, a missing event-field is treated as a synthesized string-typed freeform field
-     * rather than throwing {@link ArgumentNullException}. This is the mode used by connectors
-     * that declare `hasStaticLeftOperandFilterBuilder` — they ship no schema and let the user
-     * type the left-operand field name directly.
-     */
-    allowFreeformFields?: boolean;
-};
-export declare class JmesHelper {
-    static readonly operatorMappings: Map<FilterOperator, string>;
-    static readonly functionMappings: Map<FilterOperator, string>;
-    static readonly logicalOperatorMappings: Map<FilterGroupOperator, 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;
-        isLiteral: boolean;
-    };
-    /**
-     * Builds the JMES fragments for a single group's filters. Rows whose field name is missing
-     * in the supplied schema are either synthesized as freeform string fields (when
-     * `allowFreeformFields` is on) or rejected via {@link ArgumentNullException}. Rows without
-     * an operator or without an id are skipped — these represent UI-only in-progress rows that
-     * must not appear in the persisted expression.
-     */
-    private static _buildGroupConditions;
-    /** Converts a filter field to a corresponding JMESPath expression. */
-    private static _buildJmesPathExpression;
-    /** Compose an array filter for In/NotIn. */
-    static composeArrayInExpression(field: string, values: unknown[], isNumeric: boolean, negate: boolean): string;
-    static composeArrayJmesPathExpression(field: string, op: FilterOperator, value: unknown | null, fieldType: ClrTypeMock, mask?: string | null): string;
-    private static _composeArrayExpression;
-    static is(field: string, value: boolean): string;
-    static isNot(field: string, value: boolean): string;
-    static isEmpty(field: string): string;
-    static isNotEmpty(field: string): string;
-    static isOneOf(field: string, values: unknown[], isNumeric: boolean): string;
-    static isNotOneOf(field: string, values: unknown[], isNumeric: boolean): string;
-    private static _toJsonArray;
-    static composeJmesPathExpression(field: string, op: FilterOperator, value: WorkflowValue | null, fieldType: ClrTypeMock, mask?: string | null, translationConfiguration?: TranslationConfiguration): string;
-    private static _composeSingleValueExpression;
-    static aggregateExpressions(expressions: string[], op: FilterGroupOperator): string;
-    static aggregateExpressionGroup(expressions: string[], op: FilterGroupOperator): string;
-    static aggregateFinalExpressions(expressions: string[], op: FilterGroupOperator): string;
-    private static _getSubExpression;
-}
-export {};

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

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

@@ -1,9 +0,0 @@
-/**
- * Local shim for SW's `StringExtensions`. Covers only the members the
- * filter-builder helpers use. Mirrors `@sw/.../extension-methods/string-extensions`.
- */
-export declare class StringExtensions {
-    static readonly empty = "";
-    static isNullOrEmpty(s: string | null | undefined): boolean;
-    static isNullOrWhiteSpace(s: string | null | undefined): boolean;
-}

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

@@ -1,16 +0,0 @@
-/**
- * Shims for SW translation utilities (ported for PR #18081 support):
- * - `TranslationConfiguration` from `@uipath/studio-web-unified-build`
- * - `addExpressionWrapper` from `@sw/translation/translators/utils-translators`
- *
- * 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/helpers/trim.d.ts

@@ -1,6 +0,0 @@
-/**
- * Local shim for `lodash-es`'s `trim(string, chars)` — avoids pulling lodash
- * into the SDK bundle. Strips any leading/trailing occurrence of any character
- * in `chars`; if `chars` is omitted, trims whitespace like native `String.trim`.
- */
-export declare function trim(value: string, chars?: string): string;