@uipath/uipath-typescript 1.3.8 → 1.3.10

package/dist/processes/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var sdkLogs = require('@opentelemetry/sdk-logs');
+var coreTelemetry = require('@uipath/core-telemetry');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -613,14 +613,25 @@ class ApiClient {
             if (!text) {
                 return undefined;
             }
-            return JSON.parse(text);
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    throw new ServerError({
+                        message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                        statusCode: response.status,
+                    });
+                }
+                throw error;
+            }
         }
         catch (error) {
             // If it's already one of our errors, re-throw it
             if (error.type && error.type.includes('Error')) {
                 throw error;
             }
-            // Otherwise, it's likely a network error
+            // Otherwise, it's a genuine network/fetch failure
             throw ErrorFactory.createNetworkError(error);
         }
     }
@@ -1284,9 +1295,9 @@ class PaginationHelpers {
      * @returns Promise resolving to a paginated result
      */
     static async getAllPaginated(params) {
-        const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         const endpoint = getEndpoint(folderId);
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
             headers,
             params: additionalParams,
@@ -1314,13 +1325,13 @@ class PaginationHelpers {
      * @returns Promise resolving to an object with data and totalCount
      */
     static async getAllNonPaginated(params) {
-        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         // Set default field names
         const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
         const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
         // Determine endpoint and headers based on folderId
         const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         // Make the API call based on method
         let response;
         if (method === HTTP_METHODS.POST) {
@@ -1379,6 +1390,7 @@ class PaginationHelpers {
                 serviceAccess: config.serviceAccess,
                 getEndpoint: config.getEndpoint,
                 folderId,
+                headers: config.headers,
                 paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
@@ -1396,6 +1408,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,
@@ -1957,278 +1970,33 @@ const PROCESS_ENDPOINTS = {
 };
 
 /**
- * SDK Telemetry constants
- */
-// Connection string placeholder that will be replaced during build
-const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
-// SDK Version placeholder 
-const SDK_VERSION = "1.3.8";
-const VERSION = "Version";
-const SERVICE = "Service";
-const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
-const CLOUD_TENANT_NAME = "CloudTenantName";
-const CLOUD_URL = "CloudUrl";
-const CLOUD_CLIENT_ID = "CloudClientId";
-const CLOUD_REDIRECT_URI = "CloudRedirectUri";
-const APP_NAME = "ApplicationName";
-const CLOUD_ROLE_NAME = "uipath-ts-sdk";
-// Service and logger names
-const SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
-const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
-// Event names
-const SDK_RUN_EVENT = "Sdk.Run";
-// Default value for unknown/empty attributes
-const UNKNOWN = "";
-
-/**
- * Log exporter that sends ALL logs as Application Insights custom events
- */
-class ApplicationInsightsEventExporter {
-    constructor(connectionString) {
-        this.connectionString = connectionString;
-    }
-    export(logs, resultCallback) {
-        try {
-            logs.forEach(logRecord => {
-                this.sendAsCustomEvent(logRecord);
-            });
-            resultCallback({ code: 0 });
-        }
-        catch (error) {
-            console.debug('Failed to export logs to Application Insights:', error);
-            resultCallback({ code: 2, error });
-        }
-    }
-    shutdown() {
-        return Promise.resolve();
-    }
-    sendAsCustomEvent(logRecord) {
-        // Get event name from body or attributes
-        const eventName = logRecord.body || SDK_RUN_EVENT;
-        const payload = {
-            name: 'Microsoft.ApplicationInsights.Event',
-            time: new Date().toISOString(),
-            iKey: this.extractInstrumentationKey(),
-            data: {
-                baseType: 'EventData',
-                baseData: {
-                    ver: 2,
-                    name: eventName,
-                    properties: this.convertAttributesToProperties(logRecord.attributes || {})
-                }
-            },
-            tags: {
-                'ai.cloud.role': CLOUD_ROLE_NAME,
-                'ai.cloud.roleInstance': SDK_VERSION
-            }
-        };
-        this.sendToApplicationInsights(payload);
-    }
-    extractInstrumentationKey() {
-        const match = this.connectionString.match(/InstrumentationKey=([^;]+)/);
-        return match ? match[1] : '';
-    }
-    convertAttributesToProperties(attributes) {
-        const properties = {};
-        Object.entries(attributes || {}).forEach(([key, value]) => {
-            properties[key] = String(value);
-        });
-        return properties;
-    }
-    async sendToApplicationInsights(payload) {
-        try {
-            const ingestionEndpoint = this.extractIngestionEndpoint();
-            if (!ingestionEndpoint) {
-                console.debug('No ingestion endpoint found in connection string');
-                return;
-            }
-            const url = `${ingestionEndpoint}/v2/track`;
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(payload)
-            });
-            if (!response.ok) {
-                console.debug(`Failed to send event telemetry: ${response.status} ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            console.debug('Error sending event telemetry to Application Insights:', error);
-        }
-    }
-    extractIngestionEndpoint() {
-        const match = this.connectionString.match(/IngestionEndpoint=([^;]+)/);
-        return match ? match[1] : '';
-    }
-}
-/**
- * Singleton telemetry client
- */
-class TelemetryClient {
-    constructor() {
-        this.isInitialized = false;
-    }
-    static getInstance() {
-        if (!TelemetryClient.instance) {
-            TelemetryClient.instance = new TelemetryClient();
-        }
-        return TelemetryClient.instance;
-    }
-    /**
-     * Initialize telemetry
-     */
-    initialize(config) {
-        if (this.isInitialized) {
-            return;
-        }
-        this.isInitialized = true;
-        if (config) {
-            this.telemetryContext = config;
-        }
-        try {
-            const connectionString = this.getConnectionString();
-            if (!connectionString) {
-                return;
-            }
-            this.setupTelemetryProvider(connectionString);
-        }
-        catch (error) {
-            // Silent failure - telemetry errors shouldn't break functionality
-            console.debug('Failed to initialize OpenTelemetry:', error);
-        }
-    }
-    getConnectionString() {
-        const connectionString = CONNECTION_STRING;
-        return connectionString;
-    }
-    setupTelemetryProvider(connectionString) {
-        const exporter = new ApplicationInsightsEventExporter(connectionString);
-        const processor = new sdkLogs.BatchLogRecordProcessor(exporter);
-        this.logProvider = new sdkLogs.LoggerProvider({
-            processors: [processor]
-        });
-        this.logger = this.logProvider.getLogger(SDK_LOGGER_NAME);
-    }
-    /**
-     * Track a telemetry event
-     */
-    track(eventName, name, extraAttributes = {}) {
-        try {
-            // Skip if logger not initialized
-            if (!this.logger) {
-                return;
-            }
-            const finalDisplayName = name || eventName;
-            const attributes = this.getEnrichedAttributes(extraAttributes, eventName);
-            // Emit as log 
-            this.logger.emit({
-                body: finalDisplayName,
-                attributes: attributes,
-                timestamp: Date.now(),
-            });
-        }
-        catch (error) {
-            // Silent failure
-            console.debug('Failed to track telemetry event:', error);
-        }
-    }
-    /**
-     * Get enriched attributes for telemetry events
-     */
-    getEnrichedAttributes(extraAttributes, eventName) {
-        const attributes = {
-            [APP_NAME]: SDK_SERVICE_NAME,
-            [VERSION]: SDK_VERSION,
-            [SERVICE]: eventName,
-            [CLOUD_URL]: this.createCloudUrl(),
-            [CLOUD_ORGANIZATION_NAME]: this.telemetryContext?.orgName || UNKNOWN,
-            [CLOUD_TENANT_NAME]: this.telemetryContext?.tenantName || UNKNOWN,
-            [CLOUD_REDIRECT_URI]: this.telemetryContext?.redirectUri || UNKNOWN,
-            [CLOUD_CLIENT_ID]: this.telemetryContext?.clientId || UNKNOWN,
-            ...extraAttributes,
-        };
-        return attributes;
-    }
-    /**
-     * Create cloud URL from base URL, organization ID, and tenant ID
-     */
-    createCloudUrl() {
-        const baseUrl = this.telemetryContext?.baseUrl;
-        const orgId = this.telemetryContext?.orgName;
-        const tenantId = this.telemetryContext?.tenantName;
-        if (!baseUrl || !orgId || !tenantId) {
-            return UNKNOWN;
-        }
-        return `${baseUrl}/${orgId}/${tenantId}`;
-    }
-}
-// Export singleton instance
-const telemetryClient = TelemetryClient.getInstance();
+ * SDK Telemetry constants.
+ *
+ * Only the SDK's identity (version, service name, role name, …) lives
+ * here. The Application Insights connection string is injected into
+ * `@uipath/core-telemetry` itself at publish time, and the generic attribute
+ * keys (`Version`, `Service`, `CloudOrganizationName`, …) are owned by
+ * `@uipath/core-telemetry` and consumed there — they are not part of the
+ * SDK's public API.
+ */
+/** SDK version placeholder — patched by the SDK publish workflow. */
+const CLOUD_ROLE_NAME = 'uipath-ts-sdk';
 
 /**
- * SDK Track decorator and function for telemetry
- */
-/**
- * Common tracking logic shared between method and function decorators
- */
-function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, opts) {
-    return function (...args) {
-        // Determine if we should track this call
-        let shouldTrack = true;
-        if (opts.condition !== undefined) {
-            if (typeof opts.condition === 'function') {
-                shouldTrack = opts.condition.apply(this, args);
-            }
-            else {
-                shouldTrack = opts.condition;
-            }
-        }
-        // Track the event if enabled
-        if (shouldTrack) {
-            // Use the full name provided in the decorator (e.g., "Queue.GetAll")
-            const serviceMethod = typeof nameOrOptions === 'string'
-                ? nameOrOptions
-                : fallbackName;
-            // Use 'Sdk.Run' as the name and serviceMethod as the service
-            telemetryClient.track(serviceMethod, SDK_RUN_EVENT, opts.attributes);
-        }
-        // Execute the original function
-        return originalFunction.apply(this, args);
-    };
-}
-/**
- * Track decorator that can be used to automatically track function calls
- *
- * Usage:
- * @track("Service.Method")
- * function myFunction() { ... }
- *
- * @track("Queue.GetAll")
- * async getAll() { ... }
- *
- * @track("Tasks.Create")
- * async create() { ... }
+ * UiPath TypeScript SDK Telemetry
  *
- * @track("Assets.Update", { condition: false })
- * function myFunction() { ... }
- *
- * @track("Processes.Start", { attributes: { customProp: "value" } })
- * function myFunction() { ... }
- */
-function track(nameOrOptions, options) {
-    return function decorator(_target, propertyKey, descriptor) {
-        const opts = typeof nameOrOptions === 'object' ? nameOrOptions : {};
-        if (descriptor && typeof descriptor.value === 'function') {
-            // Method decorator
-            descriptor.value = createTrackedFunction(descriptor.value, nameOrOptions, propertyKey || 'unknown_method', opts);
-            return descriptor;
-        }
-        // Function decorator
-        return (originalFunction) => createTrackedFunction(originalFunction, nameOrOptions, originalFunction.name || 'unknown_function', opts);
-    };
-}
+ * Constructs the SDK's own `TelemetryClient` and binds the SDK-local
+ * `track` / `trackEvent` to it. Each consumer of `@uipath/core-telemetry`
+ * does this independently, so events carry their own consumer's identity
+ * and tenant context.
+ */
+// Keyed by `CLOUD_ROLE_NAME` so every SDK subpath bundle resolves to the
+// same `TelemetryClient` instance at runtime. A single `initialize(...)`
+// from the `UiPath` constructor therefore wires up `@track` decorators
+// across every subpath bundle (`assets`, `feedback`, `tasks`, …).
+const sdkClient = coreTelemetry.getOrCreateClient(CLOUD_ROLE_NAME);
+const track = coreTelemetry.createTrack(sdkClient);
+coreTelemetry.createTrackEvent(sdkClient);
 
 /**
  * Service for interacting with UiPath Orchestrator Processes API
@@ -2298,33 +2066,32 @@ class ProcessService extends FolderScopedService {
             }
         }, options);
     }
-    /**
-     * Starts a process execution (job)
-     *
-     * @param request - Process start request body
-     * @param folderId - Required folder ID
-     * @param options - Optional query parameters
-     * @returns Promise resolving to the created jobs
-     *
-     * @example
-     * ```typescript
-     * import { Processes } from '@uipath/uipath-typescript/processes';
-     *
-     * const processes = new Processes(sdk);
-     *
-     * // Start a process by process key
-     * const jobs = await processes.start({
-     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-     * }, 123); // folderId is required
-     *
-     * // Start a process by name with specific robots
-     * const jobs = await processes.start({
-     *   processName: "MyProcess"
-     * }, 123); // folderId is required
-     * ```
-     */
-    async start(request, folderId, options = {}) {
-        const headers = createHeaders({ [FOLDER_ID]: folderId });
+    async start(request, optionsOrFolderId, legacyOptions) {
+        // Normalize the two overload forms into a single internal shape.
+        let folderId;
+        let folderKey;
+        let folderPath;
+        let queryOptions;
+        if (typeof optionsOrFolderId === 'number') {
+            // Deprecated positional form: start(request, folderId, options?)
+            folderId = optionsOrFolderId;
+            queryOptions = legacyOptions ?? {};
+        }
+        else {
+            // Preferred form: start(request, options?)
+            const { folderId: fid, folderKey: fkey, folderPath: fpath, ...rest } = optionsOrFolderId ?? {};
+            folderId = fid;
+            folderKey = fkey;
+            folderPath = fpath;
+            queryOptions = rest;
+        }
+        const headers = resolveFolderHeaders({
+            folderId,
+            folderKey,
+            folderPath,
+            resourceType: 'processes.start',
+            fallbackFolderKey: this.config.folderKey,
+        });
         // Transform SDK field names to API field names (e.g., processKey → releaseKey)
         const apiRequest = transformRequest(request, ProcessMap);
         // Create the request object according to API spec
@@ -2332,8 +2099,8 @@ class ProcessService extends FolderScopedService {
             startInfo: apiRequest
         };
         // Prefix all query parameter keys with '$' for OData
-        const keysToPrefix = Object.keys(options);
-        const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+        const keysToPrefix = Object.keys(queryOptions);
+        const apiOptions = addPrefixToKeys(queryOptions, ODATA_PREFIX, keysToPrefix);
         const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
             params: apiOptions,
             headers

package/dist/processes/index.d.ts

@@ -744,6 +744,17 @@ interface ProcessGetByIdOptions extends BaseOptions {
  */
 interface ProcessGetByNameOptions extends FolderScopedOptions {
 }
+/**
+ * Options for starting a process. Combines folder scoping
+ * (`folderId` / `folderKey` / `folderPath`) with the OData query options
+ * (`expand`, `select`, `filter`, `orderby`) accepted by the start endpoint.
+ *
+ * Folder scoping is optional in the type — the SDK falls back to the
+ * init-time folderKey (e.g. `<meta name="uipath:folder-key">` in coded-app
+ * deployments). A `ValidationError` is raised when neither is provided.
+ */
+interface ProcessStartOptions extends FolderScopedOptions, RequestOptions {
+}
 
 /**
  * Service for managing and executing UiPath Automation Processes.
@@ -840,26 +851,45 @@ interface ProcessServiceModel {
      */
     getByName(name: string, options?: ProcessGetByNameOptions): Promise<ProcessGetResponse>;
     /**
-     * Starts a process with the specified configuration
+     * Starts a process with the specified configuration.
+     *
+     * Folder context can be supplied as `folderId`, `folderKey`, or `folderPath`
+     * inside the options.
      *
      * @param request - Process start configuration
-     * @param folderId - Required folder ID
-     * @param options - Optional request options
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`, `filter`, `orderby`)
      * @returns Promise resolving to array of started process instances
      * {@link ProcessStartResponse}
      * @example
      * ```typescript
-     * // Start a process by process key
-     * const result = await processes.start({
-     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-     * }, <folderId>); // folderId is required
-     *
-     * // Start a process by name with specific robots
-     * const result = await processes.start({
-     *   processName: "MyProcess"
-     * }, <folderId>); // folderId is required
+     * // By folder ID
+     * await processes.start({ processKey: '<processKey>' }, { folderId: <folderId> });
+     *
+     * // By folder key (GUID)
+     * await processes.start({ processKey: '<processKey>' }, { folderKey: '5f6dadf1-3677-49dc-8aca-c2999dd4b3ba' });
+     *
+     * // By folder path
+     * await processes.start({ processKey: '<processKey>' }, { folderPath: 'Shared/Finance' });
+     *
+     * // Start by process name (instead of processKey)
+     * await processes.start({ processName: 'MyProcess' }, { folderId: <folderId> });
+     *
+     * // With additional options
+     * await processes.start({ processKey: '<processKey>' }, { folderId: <folderId>, expand: 'Robot' });
      * ```
      */
+    start(request: ProcessStartRequest, options?: ProcessStartOptions): Promise<ProcessStartResponse[]>;
+    /**
+     * Starts a process — positional `folderId` form.
+     *
+     * @deprecated Use the options-object form: `start(request, { folderId })`. See {@link ProcessStartOptions} for the supported options.
+     *
+     * @param request - Process start configuration
+     * @param folderId - Required folder ID (numeric)
+     * @param options - Optional request options
+     * @returns Promise resolving to array of started process instances
+     * {@link ProcessStartResponse}
+     */
     start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
 }
 
@@ -913,12 +943,15 @@ declare class ProcessService extends FolderScopedService implements ProcessServi
      */
     getAll<T extends ProcessGetAllOptions = ProcessGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessGetResponse> : NonPaginatedResponse<ProcessGetResponse>>;
     /**
-     * Starts a process execution (job)
+     * Starts a process with the specified configuration.
      *
-     * @param request - Process start request body
-     * @param folderId - Required folder ID
-     * @param options - Optional query parameters
-     * @returns Promise resolving to the created jobs
+     * Folder context can be supplied as `folderId`, `folderKey`, or `folderPath`
+     * inside the options.
+     *
+     * @param request - Process start configuration
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`, `filter`, `orderby`)
+     * @returns Promise resolving to array of started process instances
+     * {@link ProcessStartResponse}
      *
      * @example
      * ```typescript
@@ -926,17 +959,34 @@ declare class ProcessService extends FolderScopedService implements ProcessServi
      *
      * const processes = new Processes(sdk);
      *
-     * // Start a process by process key
-     * const jobs = await processes.start({
-     *   processKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
-     * }, 123); // folderId is required
+     * // By folder ID
+     * await processes.start({ processKey: '<processKey>' }, { folderId: <folderId> });
      *
-     * // Start a process by name with specific robots
-     * const jobs = await processes.start({
-     *   processName: "MyProcess"
-     * }, 123); // folderId is required
+     * // By folder key (GUID)
+     * await processes.start({ processKey: '<processKey>' }, { folderKey: '5f6dadf1-3677-49dc-8aca-c2999dd4b3ba' });
+     *
+     * // By folder path
+     * await processes.start({ processKey: '<processKey>' }, { folderPath: 'Shared/Finance' });
+     *
+     * // Start by process name (instead of processKey)
+     * await processes.start({ processName: 'MyProcess' }, { folderId: <folderId> });
+     *
+     * // With additional options
+     * await processes.start({ processKey: '<processKey>' }, { folderId: <folderId>, expand: 'Robot' });
      * ```
      */
+    start(request: ProcessStartRequest, options?: ProcessStartOptions): Promise<ProcessStartResponse[]>;
+    /**
+     * Starts a process — positional `folderId` form.
+     *
+     * @deprecated Use the options-object form: `start(request, { folderId })`. See {@link ProcessStartOptions} for the supported options.
+     *
+     * @param request - Process start configuration
+     * @param folderId - Required folder ID (numeric)
+     * @param options - Optional request options
+     * @returns Promise resolving to array of started process instances
+     * {@link ProcessStartResponse}
+     */
     start(request: ProcessStartRequest, folderId: number, options?: RequestOptions): Promise<ProcessStartResponse[]>;
     /**
      * Gets a single process by ID
@@ -987,4 +1037,4 @@ declare class ProcessService extends FolderScopedService implements ProcessServi
 }
 
 export { JobPriority, JobSourceType, JobType, PackageSourceType, PackageType, ProcessService, ProcessService as Processes, RemoteControlAccess, RobotSize, RuntimeType, StartStrategy, StopStrategy, TargetFramework };
-export type { ArgumentMetadata, BaseProcessStartRequest, FolderProperties, JobAttachment, JobError, Machine, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetByNameOptions, ProcessGetResponse, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartRequestWithKey, ProcessStartRequestWithName, ProcessStartResponse, RobotMetadata };
+export type { ArgumentMetadata, BaseProcessStartRequest, FolderProperties, JobAttachment, JobError, Machine, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetByNameOptions, ProcessGetResponse, ProcessProperties, ProcessServiceModel, ProcessStartOptions, ProcessStartRequest, ProcessStartRequestWithKey, ProcessStartRequestWithName, ProcessStartResponse, RobotMetadata };