@uipath/maestro-sdk 0.2.0 → 0.9.0

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

@@ -0,0 +1,2 @@
+import type { PimsApiConfig } from "./types";
+export declare function createPimsConfig(): Promise<PimsApiConfig>;

package/dist/src/client.d.ts

@@ -0,0 +1,3 @@
+import type { PimsApiConfig, PimsRequestOptions } from "./types";
+export declare function pimsGet<T>(config: PimsApiConfig, path: string, options?: PimsRequestOptions): Promise<T>;
+export declare function pimsPost<T>(config: PimsApiConfig, path: string, body?: unknown, options?: PimsRequestOptions): Promise<T>;

package/dist/src/debug-http-client.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared HTTP client for Studio Web debug workflows.
+ * Provides Orchestrator, PIMS, and Studio Web API helpers.
+ * Used by flow-tool, case-tool, and maestro-tool.
+ */
+import type { OrchestratorApiConfig } from "./debug-types";
+/**
+ * Make a GET request to Orchestrator API
+ */
+export declare function orchestratorGet<T>(config: OrchestratorApiConfig, path: string): Promise<T>;
+/**
+ * Make a POST request to Orchestrator API
+ */
+export declare function orchestratorPost<T>(config: OrchestratorApiConfig, path: string, body: unknown): Promise<T>;
+/**
+ * Make a GET request to PIMS API (debug path, not /api/v1)
+ */
+export declare function debugPimsGet<T>(config: OrchestratorApiConfig, path: string): Promise<T>;
+/**
+ * Make a POST request to PIMS API (debug path, not /api/v1)
+ */
+export declare function debugPimsPost<T>(config: OrchestratorApiConfig, path: string, body: unknown): Promise<T>;
+/**
+ * Make a POST request to Studio Web backend API
+ */
+export declare function studioWebPost<T>(config: OrchestratorApiConfig, organizationName: string, path: string, body: FormData | unknown, extraHeaders?: Record<string, string>): Promise<T>;
+/**
+ * Make a DELETE request to Studio Web backend API
+ */
+export declare function studioWebDelete(config: OrchestratorApiConfig, organizationName: string, path: string): Promise<void>;

package/dist/src/debug-service.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Shared debug service utilities for Studio Web debug workflows.
+ * Provides common methods used by flow-tool, case-tool, and maestro-tool.
+ */
+import type { IFileSystem } from "@uipath/filesystem";
+import type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, OrchestratorApiConfig } from "./debug-types";
+/**
+ * Extract the first bpmn:startEvent id from BPMN XML.
+ * Falls back to "start" if no start event is found.
+ */
+export declare function extractStartEventId(bpmnXml: string): string;
+/**
+ * Fetch the personal workspace folder from Orchestrator.
+ */
+export declare function getPersonalFolderKey(config: OrchestratorApiConfig): Promise<{
+    key: string;
+    id: number;
+}>;
+export interface PersonalFolderInfo {
+    key: string;
+    id: number;
+    displayName: string;
+    fullyQualifiedName: string;
+    parentKey: string | null;
+}
+/**
+ * Fetch detailed personal workspace folder info from Orchestrator.
+ * Returns key, id, display name, fully qualified name, and parent key.
+ */
+export declare function getPersonalFolderInfo(config: OrchestratorApiConfig): Promise<PersonalFolderInfo>;
+/**
+ * Begin a debug session in Orchestrator.
+ */
+export declare function beginDebugSession(config: OrchestratorApiConfig, inputArguments?: string): Promise<BeginSessionResponse>;
+/**
+ * Create a debug instance in PIMS.
+ * @param processType - "Flow" for flow-tool, "case" for case-tool, "processOrchestration" for maestro-tool
+ */
+export declare function createDebugInstance(config: OrchestratorApiConfig, jobKey: string, solutionId: string, studioWebProjectId: string, entryPoint: string, processType?: string): Promise<DebugInstanceResponse>;
+/**
+ * Poll PIMS debug instance element-executions until terminal status.
+ */
+export declare function pollDebugInstanceStatus(config: OrchestratorApiConfig, instanceId: string, callbacks?: DebugCallbacks, pollInterval?: number, maxPolls?: number, jobKey?: string): Promise<DebugInstanceStatusResponse>;
+/**
+ * Parameters for the shared upload-and-debug lifecycle.
+ * Callers are responsible for building the .uis package and resolving
+ * the existing solution ID — this function handles the upload, session
+ * creation, polling, and result mapping.
+ */
+export interface UploadAndDebugParams {
+    /** Upload the .uis buffer/path to Studio Web. Callers provide this so
+     *  maestro-sdk doesn't need to depend on solution-sdk. */
+    upload: () => Promise<{
+        id: string;
+        projects: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
+    /** Callback to persist the returned solutionId locally (e.g. update .uipx). */
+    onSolutionId?: (solutionId: string) => Promise<void>;
+    projectName: string;
+    entryPoint: string;
+    projectType: string;
+    apiConfig: OrchestratorApiConfig;
+    organizationName: string;
+    callbacks?: DebugCallbacks;
+    pollInterval?: number;
+    maxPolls?: number;
+    beginSessionPayload?: string;
+    /** Pre-fetched folder key+id. When supplied, skips the getPersonalFolderKey
+     *  call — avoids a redundant round-trip if the caller already has it. */
+    folder?: {
+        key: string;
+        id: number;
+    };
+}
+/**
+ * Shared upload-and-debug lifecycle used by flow-tool, maestro-tool, and case-tool.
+ *
+ * 1. Uploads solution to Studio Web (via caller-provided `upload` fn)
+ * 2. Persists solutionId locally (via `onSolutionId` callback)
+ * 3. Fetches personal workspace folder
+ * 4. Begins debug session in Orchestrator
+ * 5. Creates debug instance in PIMS
+ * 6. Polls for completion
+ * 7. Returns DebugResult with solutionId and studioWebUrl
+ */
+export declare function uploadAndDebugSolution(params: UploadAndDebugParams): Promise<DebugResult>;
+/**
+ * Register connection resources on Studio Web after solution upload.
+ * Reads connection resource files from the solution directory and calls
+ * POST /resources/reference for each one, which registers the resource
+ * AND sets the debug overwrite in one call.
+ *
+ * This resolves the "Resource is not configured" warning in Studio Web
+ * for both activity and trigger connector connections.
+ */
+export declare function patchConnectionOverwrites(config: OrchestratorApiConfig, organizationName: string, solutionId: string, solutionDir: string, folder: PersonalFolderInfo, fs: IFileSystem): Promise<number>;

package/dist/src/debug-types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared type definitions for Studio Web debug workflows.
+ * Used by flow-tool, case-tool, and maestro-tool.
+ */
+export interface OrchestratorApiConfig {
+    baseUrl: string;
+    organizationId: string;
+    tenantName: string;
+    tenantId?: string;
+    authToken: string;
+    organizationUnitId?: number;
+    folderKey?: string;
+}
+export interface StudioWebDebugConfig {
+    baseUrl: string;
+    organizationId: string;
+    tenantId: string;
+    tenantName: string;
+    authToken: string;
+    organizationUnitId?: number;
+    organizationName: string;
+}
+export interface BeginSessionResponse {
+    vncTunnelUri: string | null;
+    jobKey: string;
+}
+export interface ElementExecution {
+    elementId: string;
+    elementType?: string;
+    extensionType?: string;
+    status: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface DebugResult {
+    jobKey: string;
+    instanceId: string;
+    runId: string;
+    finalStatus: string;
+    elementExecutions: ElementExecution[];
+    solutionId?: string;
+    studioWebUrl?: string;
+    variables?: DebugVariablesResponse;
+}
+export interface DebugVariablesResponse {
+    instanceId: string;
+    parentElementId: string | null;
+    globalVariables: Array<{
+        id: string;
+        name: string;
+        type: string;
+        value: unknown;
+        elementId: string;
+        source: string;
+    }>;
+    elements: Array<{
+        elementId: string;
+        elementRunId: string;
+        inputDefinitions: Record<string, unknown>;
+        inputs: Record<string, unknown>;
+        outputs: Record<string, unknown>;
+        isMarker: boolean;
+    }>;
+}
+export interface DebugCallbacks {
+    onStatusChange?: (status: string, executions: ElementExecution[]) => void;
+    onIncident?: (incidents: unknown[]) => void;
+}
+export interface DebugInstanceResponse {
+    instanceId: string;
+    runId: string;
+}
+export interface DebugInstanceStatusResponse {
+    instanceId: string;
+    status: string;
+    startedTimeUtc: string;
+    completedTimeUtc: string | null;
+    traceId: string | null;
+    elementExecutions: Array<{
+        elementId: string;
+        elementType: string;
+        status: string;
+        startedTimeUtc: string;
+        completedTimeUtc: string | null;
+        elementRuns: Array<{
+            status: string;
+            startedTimeUtc: string;
+            completedTimeUtc: string | null;
+            elementRunId: string;
+        }>;
+    }>;
+}

package/dist/src/flags/manifest-flags.d.ts

@@ -0,0 +1,4 @@
+/** flow-core feature-flag constants — each gates a node category in ManifestClient. */
+export declare const FLAG_CONNECTOR_NODES = "canvas.mfe.dap-component";
+/** Returns a `getFeatureFlag` callback that enables the given flags. */
+export declare function buildFeatureFlagResolver(flags: readonly string[]): (flag: string) => boolean;

package/dist/src/index.d.ts

@@ -0,0 +1,23 @@
+export { pimsGet, pimsPost } from "./client";
+export { createPimsConfig } from "./client-factory";
+export { debugPimsGet, debugPimsPost, orchestratorGet, orchestratorPost, studioWebDelete, studioWebPost, } from "./debug-http-client";
+export type { PersonalFolderInfo, UploadAndDebugParams } from "./debug-service";
+export { beginDebugSession, createDebugInstance, extractStartEventId, getPersonalFolderInfo, getPersonalFolderKey, patchConnectionOverwrites, pollDebugInstanceStatus, uploadAndDebugSolution, } from "./debug-service";
+export type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, DebugVariablesResponse, ElementExecution, OrchestratorApiConfig, StudioWebDebugConfig, } from "./debug-types";
+export { BPMN_SPEC } from "./manifest/bpmn-spec";
+export type { BpmnExtensionType, DiscoveredConnector, DiscoveredProcess, MaestroRegistry, RegistryMetadata, } from "./manifest/types";
+export { buildQueryString } from "./query-string";
+export type { CompactField, ConnectorInfo, ConnectorMethodInfo, ContextEntry, FieldReference, FilterCondition, FilterField, FilterOperator, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, ParsedFilters, SyncMetadata, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./registry/index.js";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractMultipartParameters, extractTriggerFilterFields, FilterParseError, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, filterNodes, getConnectorConfiguration, getConnectorInfo, getNode, getNodeEnriched, hashContent, isConnectorNode, isConnectorTriggerNode, listNodes, loadIndexMetadata, loadNodeIndex, MANAGED_HTTP_CONNECTOR_KEY, parseFilterString, pullNodes, pullRemoteNodes, registerRegistryCommand, resolveNodeStorageDir, saveIndexMetadata, saveNodeIndex, searchNodes, searchNodesWithFilters, searchWithFilters, } from "./registry/index.js";
+export { getEnrichedActivityMetadata, getExtensionType, getRegistry, pullRegistry, searchRegistry, } from "./registry/registry-service";
+export { CACHE_EXPIRATION_MS, loadRegistry, loadRegistryMetadata, saveRegistry, } from "./registry/storage";
+export type { IncidentCommandsConfig } from "./shared-commands/incidents";
+export { registerSharedIncidentCommands } from "./shared-commands/incidents";
+export type { InstanceCommandsConfig } from "./shared-commands/instances";
+export { registerSharedInstanceCommands } from "./shared-commands/instances";
+export type { ProcessesCommandsConfig } from "./shared-commands/processes";
+export { registerSharedProcessesCommands } from "./shared-commands/processes";
+export type { TraceEvent } from "./shared-utils";
+export { formatTraceLine, formatTraceStatus, readStdin, VALID_PACKAGE_NAME_REGEX, VALID_PROJECT_NAME_REGEX, } from "./shared-utils";
+export type { ElementExecutionApi, ElementMetaData, GetInstanceElementExecutionsResponse, GlobalVariableMetaData, GoToCursorsResponse, GoToTransition, MaestroProcessSummary, PimsApiConfig, PimsRequestOptions, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessInstance, ProcessInstanceGetVariablesResponse, ProcessInstanceOperationResponse, ProcessInstanceRun, } from "./types";
+export { withPimsCall } from "./with-pims-call";

package/dist/src/manifest/bpmn-spec.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Static BPMN spec — OOTB extension types, BPMN elements, and serialization rules.
+ *
+ * The raw JSON is extracted from the PO.Frontend canvas and checked in as
+ * `bpmn-spec.json`.  This module re-exports it as a typed constant so the
+ * rest of the registry layer can consume it without additional parsing.
+ */
+import type { BpmnExtensionType } from "./types.js";
+export interface BpmnSpec {
+    version: string;
+    source: string;
+    extractedFrom?: Record<string, string>;
+    extensionTypes: Record<string, BpmnExtensionType>;
+    bpmnElements: Record<string, unknown>;
+    serializationRules: Record<string, unknown>;
+}
+/**
+ * The static BPMN spec as a typed constant.
+ * Contains all OOTB extension types, BPMN element definitions, and
+ * serialization rules extracted from the frontend codebase.
+ */
+export declare const BPMN_SPEC: BpmnSpec;

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

@@ -0,0 +1,135 @@
+/**
+ * Type definitions for the Maestro BPMN registry.
+ *
+ * The registry combines a static BPMN spec (OOTB extension types, elements,
+ * serialization rules) with dynamically discovered resources (IS connectors,
+ * Orchestrator processes) into a single queryable cache.
+ */
+/** Describes a single field in contextFields or inputFields. */
+export interface BpmnFieldDefinition {
+    /** Field name as it appears in BPMN XML context/input */
+    name: string;
+    /** Human-readable display name */
+    displayName?: string;
+    /** Data type: "string", "number", "json", "object", "boolean", "duration" */
+    type: string;
+    /** Whether the field is required for validation */
+    required: boolean;
+    /** Whether the field is hidden from the UI (present in XML but not shown) */
+    hidden: boolean;
+    /** Whether this field is the primary key that identifies the selected resource */
+    isPrimaryKey: boolean;
+    /** Whether this field references a binding (value uses =bindings.<bindingId> pattern) */
+    binding: boolean;
+    /** Default value if any */
+    defaultValue?: string | number | boolean | Record<string, unknown> | null;
+    /** Allowed enum values */
+    enum?: string[];
+    /** Brief description of the field's purpose */
+    description?: string | null;
+    /** Target attribute for serialization (e.g. "body", "bodyField") */
+    target?: string;
+    /** Binding info for resource-linked fields (process, queue, connection) */
+    bindingInfo?: {
+        resource: string;
+        resourceKeyPattern: string;
+        propertyAttribute?: string;
+    };
+}
+/** Describes a single UiPath BPMN extension type (e.g. Orchestrator.StartJob). */
+export interface BpmnExtensionType {
+    extensionType: string;
+    label: string;
+    bpmnElement: string;
+    placements: Record<string, {
+        type: string;
+        eventDefinition?: {
+            type: string;
+        };
+    }>;
+    extensionTag: "uipath:activity" | "uipath:event" | "uipath:mapping";
+    contextFields: BpmnFieldDefinition[];
+    inputPattern: "mergedBody" | "separateInputs" | "splitInputsItemData" | "scriptArgs" | "none";
+    inputName?: string;
+    inputTarget?: string;
+    outputSource?: string | null;
+    outputType?: string | null;
+    outputName?: string;
+    bindingPattern: "connection" | "process" | "queue" | "businessRule" | "none";
+    bindingInfo?: {
+        resource: string;
+        resourceKeyPattern: string;
+        propertyAttribute: string;
+        contextField: string;
+    };
+    requiresDiscovery: boolean;
+    discoveryNotes?: string;
+    isDynamic?: boolean;
+    designSchemaSharedWith?: string;
+    useRelativeSource?: boolean;
+    /** Minimal but complete XML snippet for this extension type (moddle-validated) */
+    xmlTemplate?: string | null;
+    inputFields?: BpmnFieldDefinition[];
+    inputNotes?: string;
+    contextFieldNotes?: string;
+    extensionTagNotes?: string;
+    bpmnElementNotes?: string;
+    outputNotes?: string;
+    inputFieldNotes?: string;
+}
+/** A connector discovered from Integration Service. */
+export interface DiscoveredConnector {
+    key: string;
+    name: string;
+    connections: Array<{
+        id: string;
+        name: string;
+        state: string;
+        folder: string;
+        folderKey: string;
+    }>;
+    activities: Array<{
+        name: string;
+        displayName: string;
+        objectName: string;
+        method: string;
+        operation: string;
+    }>;
+    triggers: Array<{
+        name: string;
+        displayName: string;
+        objectName: string;
+    }>;
+}
+/** A process / agent / API workflow discovered from Orchestrator. */
+export interface DiscoveredProcess {
+    key: string;
+    name: string;
+    processKey: string;
+    type: string;
+    folder: string;
+    folderKey: string;
+}
+/** The complete cached registry object. */
+export interface MaestroRegistry {
+    version: string;
+    lastSync: number;
+    hash: string;
+    static: {
+        extensionTypes: Record<string, BpmnExtensionType>;
+        bpmnElements: Record<string, unknown>;
+        serializationRules: Record<string, unknown>;
+    };
+    discovered: {
+        connectors: DiscoveredConnector[];
+        processes: DiscoveredProcess[];
+    };
+}
+/** Lightweight metadata stored alongside the full registry cache. */
+export interface RegistryMetadata {
+    lastSync: number;
+    hash: string;
+    extensionTypeCount: number;
+    connectorCount: number;
+    processCount: number;
+}

package/dist/src/query-string.d.ts

@@ -0,0 +1 @@
+export declare function buildQueryString(params: Record<string, string | number | undefined>): string;

package/dist/src/registry/command.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+/**
+ * Register the 'registry' resource command with nested actions.
+ *
+ * The registry is shared across UiPath workflow surfaces (flow, maestro, …).
+ * Each tool exposes the same actions under its own command prefix, e.g.
+ * `uip flow registry pull` or `uip maestro registry pull`.
+ *
+ * @param program       Parent commander program/command to attach to
+ * @param commandPrefix Tool prefix (e.g. "maestro flow" or "maestro bpmn") used in help text
+ */
+export declare const registerRegistryCommand: (program: Command, commandPrefix: string) => void;

package/dist/src/registry/filter-engine.d.ts

@@ -0,0 +1,11 @@
+import type { NodeManifest } from "@uipath/flow-core";
+import type { ParsedFilters } from "./types";
+/**
+ * Filter nodes based on provided filter conditions
+ */
+export declare function filterNodes(nodes: NodeManifest[], parsedFilters: ParsedFilters): NodeManifest[];
+/**
+ * Advanced search with filters and keyword
+ * Combines filter conditions with keyword search
+ */
+export declare function searchWithFilters(nodes: NodeManifest[], keyword?: string, filters?: ParsedFilters): NodeManifest[];

package/dist/src/registry/filter-parser.d.ts

@@ -0,0 +1,18 @@
+import type { ParsedFilters } from "./types";
+type FilterParseErrorCode = "INVALID_FORMAT" | "INVALID_FIELD" | "INVALID_OPERATOR";
+export declare class FilterParseError extends Error {
+    readonly code: FilterParseErrorCode;
+    readonly token: string;
+    constructor(message: string, code: FilterParseErrorCode, token: string);
+}
+/**
+ * Parse filter string into structured filter conditions
+ *
+ * Simple approach: Split on commas that are followed by a field name pattern
+ *
+ * @example
+ * parseFilterString("category=connector,displayname=slack")
+ * parseFilterString("category:in=connector,agent,process")
+ */
+export declare function parseFilterString(filterString: string): ParsedFilters;
+export {};

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

@@ -0,0 +1,11 @@
+export { buildFeatureFlagResolver, FLAG_CONNECTOR_NODES, } from "../flags/manifest-flags.js";
+export { registerRegistryCommand } from "./command.js";
+export { filterNodes, searchWithFilters, } from "./filter-engine.js";
+export { FilterParseError, parseFilterString } from "./filter-parser.js";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractMultipartParameters, extractTriggerFilterFields, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, isConnectorNode, isConnectorTriggerNode, MANAGED_HTTP_CONNECTOR_KEY, } from "./integration-service-fetcher.js";
+export type { CompactField, ConnectorInfo, ConnectorMethodInfo, ContextEntry, FieldReference, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./integration-service-metadata.types";
+export { hashContent, loadIndexMetadata, loadNodeIndex, resolveNodeStorageDir, type SyncMetadata, saveIndexMetadata, saveNodeIndex, } from "./node-storage.js";
+export { getNode, getNodeEnriched, listNodes, pullNodes, pullRemoteNodes, searchNodes, searchNodesWithFilters, } from "./node-sync-service.js";
+export type { SolutionContext } from "./solution-discovery.js";
+export { buildInSolutionNodeManifests, findSolutionFromCwd, readProjectEntryPointIO, } from "./solution-discovery.js";
+export type { FilterCondition, FilterField, FilterOperator, ParsedFilters, } from "./types";

package/dist/src/registry/integration-service-fetcher.d.ts

@@ -0,0 +1,34 @@
+import type { NodeManifest } from "@uipath/flow-core";
+import type { CompactField, ConnectorConfiguration, ConnectorInfo, ISMetadata, TriggerObjectMetadata } from "./integration-service-metadata.types";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, extractMultipartParameters, MANAGED_HTTP_CONNECTOR_KEY, } from "@uipath/integrationservice-sdk";
+export declare function isConnectorNode(node: NodeManifest): boolean;
+export declare function isConnectorTriggerNode(node: NodeManifest): boolean;
+export declare function extractTriggerFilterFields(metadata: TriggerObjectMetadata): CompactField[];
+export declare function fetchConnectorTriggerMetadata(connectorKey: string, operationName: string, objectName: string, connectionId: string): Promise<TriggerObjectMetadata>;
+export declare function getConnectorConfiguration(node: NodeManifest): ConnectorConfiguration | null;
+export declare function getConnectorInfo(node: NodeManifest): ConnectorInfo | null;
+/**
+ * Fetches metadata from Integration Service for a connector node.
+ * When connectionId is provided, uses the instance-specific endpoint
+ * which returns custom fields tied to that connection/account.
+ * Without connectionId, returns only standard/base fields.
+ */
+export interface ConnectionInfo {
+    id: string;
+    name: string;
+    connectorKey: string;
+    connectorName: string;
+    connectorVersion: string | null;
+    pollingInterval: number | null;
+}
+/**
+ * Fetch connection details by ID from Integration Service.
+ */
+export declare function fetchConnectionInfo(connectionId: string): Promise<ConnectionInfo>;
+export declare function fetchConnectorMetadata(connectorKey: string, objectName: string, connectionId?: string): Promise<ISMetadata>;
+/**
+ * Unified enrichment entry point for connector nodes.
+ * Non-connector nodes are returned as-is.
+ * Connector nodes are enriched with live IS metadata (trigger or activity).
+ */
+export declare function enrichConnectorNode(node: NodeManifest, connectionId?: string): Promise<NodeManifest>;

package/dist/src/registry/integration-service-metadata.types.d.ts

@@ -0,0 +1,68 @@
+export type { ConnectorMethodInfo, FieldReference, InputMetadata, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, MultipartParam, } from "@uipath/integrationservice-sdk";
+export type ContextEntry = {
+    name: string;
+    value?: string;
+    type?: string;
+};
+export type CompactField = {
+    name: string;
+    displayName: string;
+    type: string;
+    required: boolean;
+    description?: string;
+    responseOnly?: true;
+    enum?: unknown[];
+    reference?: FieldReference;
+};
+export type ConnectorConfiguration = {
+    connectorKey: string;
+    objectName: string;
+    activityType: string;
+    version: string;
+    supportsStreaming: boolean;
+    /** Present on activity nodes (e.g. "POST", "GET"). Absent on trigger nodes. */
+    httpMethod?: string;
+    /** Present on activity nodes (e.g. "standard"). Absent on trigger nodes. */
+    subType?: string;
+    /** Present on trigger nodes (e.g. "EMAIL_SENT"). Absent on activity nodes. */
+    eventOperation?: string;
+    /** Present on trigger nodes (e.g. "polling", "webhooks"). Absent on activity nodes. */
+    eventMode?: string;
+};
+export type ConnectorInfo = {
+    connectorKey: string;
+    objectName: string;
+    method: string;
+    activityType: string;
+};
+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/registry/node-storage.d.ts

@@ -0,0 +1,51 @@
+import type { NodeManifest } from "@uipath/flow-core";
+/**
+ * Metadata about a node source sync operation
+ */
+export interface SyncMetadata {
+    lastSync: number;
+    nodeCount: number;
+    hash: string;
+}
+/**
+ * Resolve the absolute path to the nodes storage directory.
+ * Default location: ~/.uipath/nodes/
+ *
+ * @returns Absolute path to the nodes directory
+ */
+export declare function resolveNodeStorageDir(): Promise<string>;
+/**
+ * Generate SHA-256 hash of content for change detection
+ *
+ * @param content - String content to hash
+ * @returns Hex string of the hash
+ */
+export declare function hashContent(content: string): Promise<string>;
+/**
+ * Save nodes directly to the index file
+ * Bypasses the source aggregation and saves nodes directly
+ * Also updates the index metadata
+ *
+ * @param nodes - Array of nodes to save
+ * @returns Number of nodes saved
+ */
+export declare function saveNodeIndex(nodes: NodeManifest[]): Promise<number>;
+/**
+ * Load the aggregated node index
+ *
+ * @returns Array of all nodes from all sources
+ * @throws Error if no index exists (user needs to run pull first)
+ */
+export declare function loadNodeIndex(): Promise<NodeManifest[]>;
+/**
+ * Save sync metadata for the aggregated node index
+ *
+ * @param metadata - Metadata to save (lastSync, nodeCount, hash)
+ */
+export declare function saveIndexMetadata(metadata: SyncMetadata): Promise<void>;
+/**
+ * Load sync metadata for the aggregated node index
+ *
+ * @returns Metadata if exists, null otherwise
+ */
+export declare function loadIndexMetadata(): Promise<SyncMetadata | null>;