@uipath/integrationservice-sdk 0.2.0 → 0.9.1

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

@@ -1,11 +1,34 @@
 import { Configuration as ConnectionsConfiguration, type InitOverrideFunction } from "../generated/connections/src/runtime.js";
 import { Configuration as ElementsConfiguration } from "../generated/elements/src/runtime.js";
+export interface ExecuteOperationResult {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    body: unknown;
+    headers: Record<string, string>;
+}
 export interface CreateApiClientOptions {
     tenant?: string;
     loginValidity?: number;
 }
 export declare function createConnectionsConfig(options?: CreateApiClientOptions): Promise<ConnectionsConfiguration>;
 export declare function createElementsConfig(options?: CreateApiClientOptions): Promise<ElementsConfiguration>;
-export declare function createApiClient<T>(ApiClass: new (config: any) => T, options?: CreateApiClientOptions): Promise<T>;
-export declare function executeOperation(options: CreateApiClientOptions | undefined, connectionId: string, objectName: string, httpMethod?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", body?: any, queryParams?: Record<string, string>): Promise<any>;
+export declare function createApiClient<T>(ApiClass: new (config: ConnectionsConfiguration | ElementsConfiguration) => T, options?: CreateApiClientOptions): Promise<T>;
+export declare function executeOperation(options: CreateApiClientOptions | undefined, connectionId: string, objectName: string, httpMethod?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", body?: unknown, queryParams?: Record<string, string>): Promise<ExecuteOperationResult>;
+/**
+ * Fetch object metadata as JSON Schema (no connection — base/standard fields only).
+ */
+export declare function getObjectMetadataAsSchema(options: CreateApiClientOptions | undefined, elementKey: string, objectName: string): Promise<unknown>;
+/**
+ * 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>;
+/**
+ * Fetch event operation metadata as JSON Schema (no connection).
+ */
+export declare function getEventObjectMetadataAsSchema(options: CreateApiClientOptions | undefined, elementKey: string, operationName: string, objectName: string): Promise<unknown>;
+/**
+ * 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>;
 export declare function folderOverride(folderKey?: string): InitOverrideFunction | undefined;

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

@@ -0,0 +1,29 @@
+import type { FilterTree } from "./filter-builder/filter-tree.js";
+import type { ConnectorMethodInfo } 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
+ * target connector's IS connection for authentication.
+ */
+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.
+ */
+export declare function buildActivityEssentialConfiguration(instanceParameters: Record<string, unknown>, methodInfo: ConnectorMethodInfo): 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
+ * 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 trigger's
+ * conditions;
+ */
+export declare function buildTriggerEssentialConfiguration(instanceParameters: Record<string, unknown>, filter?: FilterTree | null): Record<string, unknown>;

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

@@ -0,0 +1,18 @@
+import type { FilterTree } from "./filter-tree.js";
+/**
+ * Event field metadata needed to serialize a filter to JMESPath.
+ *
+ * Only carries what the generator needs (name + primitive type kind). The
+ * caller extracts this from `TriggerObjectMetadata.fields` before invoking
+ * {@link buildFilter}.
+ */
+export type FilterFieldType = "string" | "number" | "integer" | "boolean" | "date-time";
+export type FilterFieldMetadata = {
+    name: string;
+    type: FilterFieldType;
+};
+/** 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/filter-group-operator.d.ts

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

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

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

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

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

@@ -0,0 +1,47 @@
+/**
+ * IS trigger filter builder — produces the paired `filter` tree and
+ * derived `filterExpression` that Studio Web and the Maestro runtime consume.
+ *
+ * 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";
+/**
+ * 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.
+ */
+export declare class FilterNotSupportedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Build the paired `filter` tree and `filterExpression` for an IS trigger.
+ *
+ * Generation is delegated to `JmesHelper.buildFilterExpression` (verbatim SW
+ * port) so the CLI's expression output stays byte-identical to SW's.
+ */
+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;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+/**
+ * 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 { 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>;
+    static buildMandatoryFilterExpression(fieldArguments: Map<string, unknown>): string;
+    /** 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/string-extensions.d.ts

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

@@ -0,0 +1,11 @@
+/**
+ * TEMP no-op shims for SW translation utilities:
+ * - `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.
+ */
+export type TranslationConfiguration = unknown;
+export declare function addExpressionWrapper(value: string | undefined, _translationConfiguration?: TranslationConfiguration): string;

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

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

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

@@ -0,0 +1,6 @@
+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 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";

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

@@ -0,0 +1,21 @@
+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.
+ */
+export declare function extractMultipartParameters(params: ISMetadataParam[]): MultipartParam[];
+/**
+ * Build inputMetadata from multipart params and operation type.
+ *
+ * When `maxPageSize` is provided (from `ConnectorMethodInfo.pagination.maxPageSize`
+ * or connector-level configurations), it is used for list operations instead of the
+ * default 1000 cap.  StudioWeb resolves this from
+ * `objectMethod.Pagination.MaxPageSize ?? connectorConfigurations.GetMaxPageSize()`.
+ *
+ * Returns undefined when there's nothing to report.
+ */
+export declare function buildInputMetadata(multipartParams: MultipartParam[], operation: string, maxPageSize?: number): InputMetadata | undefined;

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

@@ -0,0 +1,105 @@
+/**
+ * DAP (Design-time Automation Platform) types for Integration Service metadata.
+ *
+ * These types represent the shape of metadata returned by the IS Elements API
+ * and are used by essential configuration builders across multiple tools
+ * (flow-tool, case-tool, coded-apps, etc.).
+ */
+export type ISMetadataParam = {
+    name: string;
+    description: string;
+    /** Where this parameter is sent: "query", "path", "body", or "multipart". */
+    type?: string;
+    dataType: string;
+    required: boolean;
+    curated: boolean;
+    displayName: string;
+    reference?: Record<string, unknown>;
+    defaultValue?: unknown;
+};
+export type MultipartParam = {
+    name: string;
+    dataType: string;
+};
+export type InputMetadata = {
+    type?: string;
+    multipart?: {
+        bodyFieldName: string;
+    };
+    operation?: string;
+    pagination?: {
+        maxPageSize: number;
+    };
+};
+export type ConnectorMethodInfo = {
+    operation: string;
+    description: string;
+    method: string;
+    parameters: ISMetadataParam[];
+    path: string;
+    operationId: string;
+    /** Pagination details from IS metadata (per-operation). */
+    pagination?: {
+        maxPageSize?: number;
+    };
+};
+export type FieldReference = {
+    objectName: string;
+    lookupValue: string;
+    lookupNames?: string[];
+    path?: string;
+    childPath?: string;
+};
+export type ISFieldMethod = {
+    request: boolean;
+    requestCurated?: boolean;
+    response: boolean;
+    responseCurated?: boolean;
+    required: boolean;
+};
+export type ISField = {
+    name: string;
+    type: string;
+    displayName: string;
+    description?: string;
+    method: Record<string, ISFieldMethod>;
+    enum?: unknown[];
+    reference?: FieldReference;
+};
+export type ISMetadata = {
+    fields?: Record<string, ISField> | ISField[];
+    metadata?: {
+        method?: Record<string, ConnectorMethodInfo>;
+    };
+};
+export type TriggerFieldEvent = {
+    name: string;
+    curated: boolean;
+    required: boolean;
+    designOverrides?: {
+        displayName?: string;
+        description?: string;
+    };
+};
+export type TriggerField = {
+    name: string;
+    type: string;
+    displayName: string;
+    custom?: string;
+    events?: Record<string, TriggerFieldEvent>;
+    isCuratedEventField?: boolean;
+    reference?: FieldReference;
+    enum?: unknown[];
+    order?: number;
+    description?: string;
+};
+export type TriggerObjectMetadata = {
+    name: string;
+    path: string;
+    type: string;
+    subType: string;
+    elementKey: string;
+    eventMode: string;
+    custom: string;
+    fields: Record<string, TriggerField>;
+};

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

@@ -0,0 +1,41 @@
+export { validateConfiguration, validateConnectionId, validateEndpoint, validateEventMode, validateEventType, validateFolderKey, validateHttpMethod, validateMethodInMetadata, 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";
+/**
+ * Default rule set — structural checks first, then metadata-aware.
+ * Metadata-aware rules gracefully return [] when metadata is absent.
+ *
+ * Frozen via `readonly` to prevent cross-consumer mutation.
+ * Compose a new array to add or remove rules:
+ * `validateIntSvcNode(ctx, [...DEFAULT_RULES, myRule])`
+ */
+export declare const DEFAULT_RULES: readonly ValidationRule[];
+/**
+ * Run validation rules against an Integration Service connector node.
+ *
+ * @param context  Surface-agnostic node data (flow JSON, XAML, BPMN, etc.)
+ * @param rules    Rules to run — defaults to {@link DEFAULT_RULES}.
+ *                 Pass a custom array to add, remove, or reorder checks.
+ * @returns        Issues found — empty array means the node is valid.
+ *
+ * @example
+ * ```ts
+ * import { validateIntSvcNode, type ConnectorValidationContext } from "@uipath/integrationservice-sdk";
+ *
+ * const issues = validateIntSvcNode({
+ *     nodeKind: "activity",
+ *     connectionId: detail.connectionId,
+ *     folderKey: detail.connectionFolderKey,
+ *     objectName,
+ *     httpMethod: detail.method,
+ *     endpoint: detail.endpoint,
+ *     bodyParameters: detail.bodyParameters,
+ *     pathParameters: detail.pathParameters,
+ *     configuration: detail.configuration,
+ *     methodInfo,   // from fetchConnectorMetadata
+ *     metadata,     // from fetchConnectorMetadata
+ * });
+ * detail.errorState = { issues };
+ * ```
+ */
+export declare function validateIntSvcNode(context: ConnectorValidationContext, rules?: readonly ValidationRule[]): Issue[];

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

@@ -0,0 +1,47 @@
+import type { ConnectorValidationContext, Issue } from "./types.js";
+/** ConnectionId must be present and non-empty.  Maps to DAP-RT-1002. */
+export declare function validateConnectionId(context: ConnectorValidationContext): Issue[];
+/** FolderKey must be present and non-empty. */
+export declare function validateFolderKey(context: ConnectorValidationContext): Issue[];
+/** Activity nodes must have a valid HTTP method.  Maps to DAP-RT-1100. */
+export declare function validateHttpMethod(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. */
+export declare function validateObjectName(context: ConnectorValidationContext): Issue[];
+/** Trigger nodes must have an eventMode. */
+export declare function validateEventMode(context: ConnectorValidationContext): Issue[];
+/** Trigger nodes must have an eventType (operation name).  Maps to DAP-RT-1053. */
+export declare function validateEventType(context: ConnectorValidationContext): Issue[];
+/**
+ * Configuration blob must exist and be parseable JSON
+ * with an essentialConfiguration envelope.  Maps to DAP-RT-1000.
+ */
+export declare function validateConfiguration(context: ConnectorValidationContext): Issue[];
+/**
+ * Path template variables (e.g. `/{conversationId}`) must have
+ * matching entries in pathParameters.
+ */
+export declare function validatePathTemplateParams(context: ConnectorValidationContext): Issue[];
+/**
+ * The configured HTTP method must exist in the IS metadata method map.
+ * Maps to DAP-DT-2201.
+ */
+export declare function validateMethodInMetadata(context: ConnectorValidationContext): Issue[];
+/**
+ * Required method parameters (path, query, body) from IS metadata must
+ * have values in the corresponding parameter map.  Maps to DAP-RT-1003.
+ */
+export declare function validateRequiredParameters(context: ConnectorValidationContext): Issue[];
+/**
+ * Required fields from IS metadata (fields with method[httpMethod].required
+ * && method[httpMethod].request) must have values in bodyParameters.
+ * Maps to DAP-RT-1003.
+ */
+export declare function validateRequiredFields(context: ConnectorValidationContext): Issue[];
+/**
+ * Required event parameters from trigger IS metadata must have values
+ * in eventParameters.  Uses `field.events[eventType].required` to
+ * determine which fields are mandatory.  Maps to DAP-RT-1003.
+ */
+export declare function validateRequiredEventParameters(context: ConnectorValidationContext): Issue[];