@js4cytoscape/ndex-client 0.5.0-alpha.8 → 0.6.0-alpha.1

package/dist/index.d.mts

@@ -0,0 +1,1931 @@
+import { AxiosRequestConfig } from 'axios';
+
+/**
+ * Type definitions for CyNDEx (Cytoscape-NDEx Bridge) operations
+ */
+/**
+ * Configuration for CyNDEx service
+ */
+interface CyNDExConfig {
+    /** Port number for Cytoscape REST API (default: 1234) */
+    port?: number;
+    /** Base URL for Cytoscape REST API (default: 'http://127.0.0.1') */
+    cyRestBaseURL?: string;
+    /** NDEx server base URL (default: 'https://www.ndexbio.org') */
+    ndexBaseURL?: string;
+}
+/**
+ * Authentication configuration for NDEx operations
+ * This is used as parameters passed to Cytoscape for NDEx authentication
+ */
+interface CyNDExAuthConfig {
+    type: 'basic' | 'oauth';
+    username?: string;
+    password?: string;
+    idToken?: string;
+}
+/**
+ * Parameters for importing NDEx network to Cytoscape
+ */
+interface NDExImportParams {
+    serverUrl: string;
+    uuid: string;
+    accessKey?: string;
+    createView?: boolean;
+    username?: string;
+    password?: string;
+    idToken?: string;
+}
+/**
+ * Parameters for exporting Cytoscape network to NDEx
+ */
+interface NDExExportParams {
+    serverUrl: string;
+    uuid?: string;
+    username?: string;
+    password?: string;
+    idToken?: string;
+}
+/**
+ * Cytoscape network summary response
+ */
+interface CytoscapeNetworkSummary {
+    suid?: string;
+    title?: string;
+    name?: string;
+    nodeCount?: number;
+    edgeCount?: number;
+    selected?: boolean;
+    [key: string]: any;
+}
+/**
+ * CyNDEx status response
+ */
+interface CyNDExStatusResponse {
+    version?: string;
+    status?: string;
+    [key: string]: any;
+}
+/**
+ * CX2 import parameters for Cytoscape
+ */
+interface CX2ImportParams {
+    format: 'cx2';
+    collection?: string;
+    title?: string;
+}
+
+/**
+ * Core type definitions for NDEx Client Library
+ * Pragmatic TypeScript types allowing flexibility with any types where needed
+ */
+
+interface BasicAuth {
+    type: 'basic';
+    username: string;
+    password: string;
+}
+interface OAuthAuth {
+    type: 'oauth';
+    idToken: string;
+}
+interface NDExAuthResponse {
+    token?: string;
+    userId?: string;
+    userName?: string;
+    isAdmin?: boolean;
+    permissions?: string[];
+    expirationTime?: number;
+}
+interface NDExUser {
+    externalId: string;
+    userName: string;
+    firstName?: string;
+    lastName?: string;
+    emailAddress?: string;
+    website?: string;
+    description?: string;
+    image?: string;
+    isIndividual?: boolean;
+    isVerified?: boolean;
+    creationTime?: number;
+    modificationTime?: number;
+}
+interface CX1MetaDataItem {
+    name: string;
+    elementCount: number;
+    version: string;
+    idCounter?: number;
+    [key: string]: any;
+}
+interface CX1MetaDataResponse {
+    metaData: CX1MetaDataItem[];
+}
+interface CX1NetworkProperty {
+    predicateString: string;
+    value: string;
+    dataType?: 'string' | 'integer' | 'double' | 'boolean' | 'list_of_string';
+}
+interface CX2NetworkProperties {
+    [key: string]: {
+        t: string;
+        v: any;
+    };
+}
+declare enum NetworkIndexLevel {
+    NONE = "NONE",
+    BASIC = "BASIC",
+    FULL = "FULL"
+}
+interface NetworkSummaryV2 {
+    externalId: string;
+    name: string;
+    description?: string;
+    nodeCount: number;
+    edgeCount: number;
+    visibility: 'PUBLIC' | 'PRIVATE';
+    owner: string;
+    ownerUUID: string;
+    creationTime: number;
+    modificationTime: number;
+    version?: string;
+    properties?: CX1NetworkProperty[];
+    isReadOnly: boolean;
+    isValid: boolean;
+    warnings?: string[];
+    hasLayout: boolean;
+    hasSample: boolean;
+    updatedBy: string;
+    errorMessage?: string;
+    cxFormat?: string;
+    cxFileSize?: number;
+    cx2FileSize?: number;
+    isShowcase?: boolean;
+    isCompleted?: boolean;
+    doi?: string;
+    isCertified?: boolean;
+    indexLevel?: NetworkIndexLevel;
+    parentDirUUID?: string;
+    showInTrash?: boolean;
+    subnetworkIds?: string[];
+    reference?: string;
+    organism?: string;
+    disease?: string;
+    tissue?: string;
+    networkType?: string[];
+    rightsHolder?: string;
+    rights?: string;
+    sourceFormat?: string;
+}
+/**
+ * NetworkSummaryV3 - Network summary for NDEx API v3
+ *
+ * Extends NetworkSummaryV2 but uses CX2-style properties format instead of CX1 format.
+ * The main difference is in how network properties are structured:
+ *
+ * | Aspect | NetworkSummaryV2 | NetworkSummaryV3 |
+ * |--------|------------------|------------------|
+ * | **Properties Format** | `CX1NetworkProperty[]` (array) | `CX2NetworkProperties` (object) |
+ * | **Structure** | CX1-style array of property objects | CX2-style key-value map |
+ * | **Example** | `[{predicateString: "name", value: "My Network"}]` | `{name: {t: "string", v: "My Network"}}` |
+ *
+ * @example
+ * ```typescript
+ * // V2 properties format (array of objects)
+ * const v2Summary: NetworkSummaryV2 = {
+ *   externalId: "12345",
+ *   name: "Sample Network",
+ *   properties: [
+ *     { predicateString: "description", value: "A sample network", dataType: "string" },
+ *     { predicateString: "nodeCount", value: "100", dataType: "integer" }
+ *   ]
+ * };
+ *
+ * // V3 properties format (object map)
+ * const v3Summary: NetworkSummaryV3 = {
+ *   externalId: "12345",
+ *   name: "Sample Network",
+ *   properties: {
+ *     description: { t: "string", v: "A sample network" },
+ *     nodeCount: { t: "integer", v: 100 }
+ *   }
+ * };
+ * ```
+ */
+interface NetworkSummaryV3 extends Omit<NetworkSummaryV2, 'properties'> {
+    properties?: CX2NetworkProperties;
+}
+interface NetworkPermission {
+    uuid: string;
+    permission: 'READ' | 'WRITE' | 'ADMIN';
+    memberUUID: string;
+    memberAccountName?: string;
+    resourceUUID: string;
+}
+interface CX2Network$1 {
+    CXVersion: string;
+    hasFragments: boolean;
+    metaData: CX2MetaData[];
+    attributeDeclarations?: CX2AttributeDeclarations;
+    networkAttributes?: CX2NetworkAttribute[];
+    nodes?: CX2Node[];
+    edges?: CX2Edge[];
+    nodeBypass?: CX2NodeBypass[];
+    edgeBypass?: CX2EdgeBypass[];
+    visualProperties?: CX2VisualProperty;
+    status?: CX2Status[];
+}
+interface CX2MetaData {
+    name: string;
+    elementCount?: number;
+}
+interface CX2AttributeDeclarations {
+    [aspectName: string]: {
+        [attributeName: string]: {
+            d: string;
+            a?: string;
+            v?: any;
+        };
+    };
+}
+interface CX2AttributeSpec {
+    d: string;
+    v?: any;
+    s?: boolean;
+}
+interface CX2NetworkAttribute {
+    [key: string]: any;
+}
+interface CX2Node {
+    id: number;
+    x?: number;
+    y?: number;
+    z?: number;
+    v?: Record<string, any>;
+}
+interface CX2Edge {
+    id: number;
+    s: number;
+    t: number;
+    v?: Record<string, any>;
+}
+interface CX1Edge {
+    [key: string]: any;
+}
+interface CX2NodeBypass {
+    id: number;
+    v: VisualPropertyTable;
+}
+interface CX2EdgeBypass {
+    id: number;
+    v: VisualPropertyTable;
+}
+/**
+ * Visual Property Mapping Types
+ */
+declare type VPMappingType = 'DISCRETE' | 'CONTINUOUS' | 'PASSTHROUGH';
+/**
+ * Mapping Definition for visual property mappings
+ * Note: Using flexible typing for mapping definitions as they vary by type
+ */
+interface MappingDefinition {
+    mapppingList?: Array<Record<string, any>>;
+    [key: string]: any;
+}
+/**
+ * Visual Property Mapping structure
+ */
+interface VisualPropertyMapping {
+    type: VPMappingType;
+    definition: MappingDefinition;
+}
+/**
+ * Visual Property Table - holds visual property values
+ * Equivalent to server-side VisualPropertyTable class
+ */
+interface VisualPropertyTable {
+    [visualPropertyName: string]: any;
+}
+/**
+ * Table Column Visual Style - for individual visual properties
+ */
+interface TableColumnVisualStyle {
+    default?: any;
+    mapping?: VisualPropertyMapping;
+}
+/**
+ * Default Visual Properties structure
+ */
+interface DefaultVisualProperties {
+    edge?: VisualPropertyTable;
+    network?: Record<string, any>;
+    node?: VisualPropertyTable;
+}
+/**
+ * CX2 Visual Property - Main visual properties aspect
+ * Equivalent to server-side CxVisualProperty class
+ */
+interface CX2VisualProperty {
+    default?: DefaultVisualProperties;
+    edgeMapping?: Record<string, VisualPropertyMapping>;
+    nodeMapping?: Record<string, VisualPropertyMapping>;
+}
+interface CX2Status {
+    error?: string;
+    success?: boolean;
+}
+interface SearchResult {
+    numFound: number;
+    start: number;
+    networks: NetworkSummaryV2[] | NetworkSummaryV3[];
+}
+interface SearchParameters {
+    searchString?: string;
+    accountName?: string;
+    permission?: string;
+    includeGroups?: boolean;
+    admin?: string;
+    start?: number;
+    size?: number;
+    source?: string;
+}
+interface ExportFormat {
+    format: 'CX' | 'CX2' | 'XGMML' | 'SIF' | 'GRAPHML';
+    version?: string;
+}
+interface ExportRequest {
+    networkUUID: string;
+    format: ExportFormat;
+    accesskey?: string;
+}
+interface Task {
+    externalId: string;
+    taskType: string;
+    status: 'submitted' | 'processing' | 'completed' | 'failed';
+    progress?: number;
+    message?: string;
+    resource?: string;
+    startTime?: number;
+    finishTime?: number;
+    attributes?: Record<string, any>;
+}
+interface NDExClientConfig {
+    baseURL?: string;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    debug?: boolean;
+    headers?: Record<string, string>;
+    auth?: BasicAuth | OAuthAuth;
+}
+interface APIResponse<T = any> {
+    data?: T;
+    errorCode?: string;
+    message?: string;
+    description?: string;
+    stackTrace?: string;
+    timeStamp?: number;
+}
+interface APIError {
+    errorCode: string;
+    message: string;
+    description?: string;
+    stackTrace?: string;
+    timeStamp?: number;
+}
+/**
+ * Base error class for all NDEx API errors
+ */
+declare class NDExError extends Error {
+    statusCode?: number;
+    errorCode?: string;
+    description?: string;
+    constructor(message: string, statusCode?: number, errorCode?: string, description?: string);
+}
+/**
+ * Error thrown when network or request fails
+ */
+declare class NDExNetworkError extends NDExError {
+    originalError?: Error;
+    constructor(message: string, originalError?: Error);
+}
+/**
+ * Error thrown when authentication fails
+ */
+declare class NDExAuthError extends NDExError {
+    constructor(message?: string, statusCode?: number);
+}
+/**
+ * Error thrown when requested resource is not found
+ */
+declare class NDExNotFoundError extends NDExError {
+    constructor(message?: string, statusCode?: number);
+}
+/**
+ * Error thrown when request validation fails
+ */
+declare class NDExValidationError extends NDExError {
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Error thrown when server encounters an internal error
+ */
+declare class NDExServerError extends NDExError {
+    constructor(message?: string, statusCode?: number);
+}
+declare type UUID = string;
+declare type Timestamp = number;
+declare type NDExAny = any;
+interface PaginationParams {
+    start?: number;
+    size?: number;
+}
+interface AccessParams {
+    accesskey?: string;
+}
+/**
+ * CyWeb workspace object structure
+ */
+interface CyWebWorkspace {
+    externalId?: string;
+    name: string;
+    description?: string;
+    networkIds?: string[];
+    [key: string]: any;
+}
+/**
+ * Network access key response structure
+ */
+interface AccessKeyResponse {
+    accessKey: string | null;
+}
+/**
+ * Valid actions for updating access keys
+ */
+declare type AccessKeyAction = 'enable' | 'disable';
+
+/**
+ * HTTPService - Core HTTP client for NDEx API communication
+ * Handles v2/v3 endpoint routing, authentication, and error handling
+ *
+ * @note User-Agent header is set to 'NDEx-JS-Client/${version}' but only works in Node.js.
+ *       Browsers will ignore custom User-Agent headers for security reasons.
+ */
+declare class HTTPService {
+    private axiosInstance;
+    private config;
+    constructor(config?: NDExClientConfig);
+    /**
+     * Get authentication headers based on config.auth
+     */
+    private getAuthHeaders;
+    /**
+     * Build API endpoint URL with version routing
+     */
+    private buildUrl;
+    /**
+     * Generic GET request with intelligent version routing
+     */
+    get<T = any>(endpoint: string, config?: AxiosRequestConfig & {
+        version?: 'v2' | 'v3';
+    }): Promise<T>;
+    /**
+     * Generic POST request with intelligent version routing
+     */
+    post<T = any>(endpoint: string, data?: any, config?: AxiosRequestConfig & {
+        version?: 'v2' | 'v3';
+    }): Promise<T>;
+    /**
+     * Generic PUT request with intelligent version routing
+     */
+    put<T = any>(endpoint: string, data?: any, config?: AxiosRequestConfig & {
+        version?: 'v2' | 'v3';
+    }): Promise<T>;
+    /**
+     * Generic DELETE request with intelligent version routing
+     */
+    delete<T = any>(endpoint: string, config?: AxiosRequestConfig & {
+        version?: 'v2' | 'v3';
+    }): Promise<T>;
+    /**
+     * Upload a file to the NDEx API with progress tracking support
+     *
+     * This method handles file uploads using multipart/form-data encoding and supports
+     * various input types for maximum flexibility across different environments.
+     *
+     * @template T - The expected response type from the API
+     * @param endpoint - API endpoint path (e.g., 'networks' for network upload)
+     * @param file - File data to upload. Supports multiple input types:
+     *   - `File` (browser): HTML5 File object from file input or drag-and-drop
+     *   - `Blob` (browser): Binary data as Blob object
+     *   - `Buffer` (Node.js): Binary data as Buffer for server-side uploads
+     *   - `string`: Text content that will be converted to Blob (useful for CX/CX2 JSON)
+     * @param options - Upload configuration options
+     * @param options.filename - Custom filename for the upload. Defaults:
+     *   - File objects: uses `file.name`
+     *   - Other types: 'file.cx2'
+     * @param options.contentType - MIME type for string content (default: 'application/json')
+     * @param options.onProgress - Progress callback that receives percentage (0-100)
+     *   Called periodically during upload with current progress
+     * @param options.version - API version to use ('v2' or 'v3', defaults to 'v2')
+     * @param options.config - Additional Axios configuration options
+     *
+     * @returns Promise resolving to upload result
+     *
+     * @example
+     * ```typescript
+     * // Upload a File object from file input (browser)
+     * const fileInput = document.getElementById('file') as HTMLInputElement;
+     * const file = fileInput.files[0];
+     * const result = await httpService.uploadFile('networks', file, {
+     *   filename: 'my-network.cx2',
+     *   onProgress: (progress) => console.log(`Upload: ${progress}%`),
+     *   version: 'v3'
+     * });
+     *
+     * // Upload CX2 network data as string
+     * const cx2Data = JSON.stringify({ CXVersion: '2.0', networks: [...] });
+     * const result = await httpService.uploadFile('networks', cx2Data, {
+     *   filename: 'network.cx2',
+     *   contentType: 'application/json',
+     *   version: 'v3'
+     * });
+     *
+     * // Upload with progress tracking
+     * const result = await httpService.uploadFile('networks', file, {
+     *   onProgress: (progress) => {
+     *     progressBar.style.width = `${progress}%`;
+     *     console.log(`Uploading: ${progress}%`);
+     *   }
+     * });
+     * ```
+     *
+     * @throws Will throw NDExError on network errors,
+     *         server errors, or invalid file data
+     *
+     * @note The Content-Type header is automatically set to 'multipart/form-data'
+     *       and Axios will handle the boundary parameter automatically
+     */
+    uploadFile<T = any>(endpoint: string, file: File | Blob | Buffer | string, options?: {
+        filename?: string;
+        contentType?: string;
+        onProgress?: (progress: number) => void;
+        version?: 'v2' | 'v3';
+    }): Promise<T>;
+    /**
+     * Setup axios interceptors for debugging and retry logic
+     */
+    private setupInterceptors;
+    /**
+     * Handle successful API responses
+     */
+    private handleResponse;
+    /**
+     * Handle API errors by throwing appropriate NDEx error types
+     */
+    private handleError;
+    /**
+     * Throw appropriate NDEx error based on status code
+     */
+    private throwNDExError;
+    /**
+     * Update client configuration
+     */
+    updateConfig(newConfig: Partial<NDExClientConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): NDExClientConfig;
+    /**
+     * Get current authentication type
+     * @returns The type of authentication configured ('basic' | 'oauth'), or undefined if no auth is configured
+     */
+    getAuthType(): 'basic' | 'oauth' | undefined;
+    /**
+     * Get ID token from OAuth authentication
+     * @returns The ID token if OAuth auth is configured, undefined otherwise
+     */
+    getIdToken(): string | undefined;
+    /**
+     * Set ID token for OAuth authentication
+     * Creates OAuth auth configuration if no auth is currently configured
+     * @param idToken - The ID token to set
+     */
+    setIdToken(idToken: string): void;
+}
+
+/**
+ * CX2Network - Modern representation of CX2 format networks
+ * Provides utilities for creating, manipulating, and validating CX2 networks
+ */
+declare class CX2Network implements CX2Network$1 {
+    CXVersion: string;
+    hasFragments: boolean;
+    metaData: CX2MetaData[];
+    attributeDeclarations?: CX2AttributeDeclarations;
+    networkAttributes?: CX2NetworkAttribute[];
+    nodes?: CX2Node[];
+    edges?: CX2Edge[];
+    nodeBypass?: CX2NodeBypass[];
+    edgeBypass?: CX2EdgeBypass[];
+    visualProperties?: CX2VisualProperty;
+    status?: any[];
+    constructor(data?: Partial<CX2Network$1>);
+    /**
+     * Create a new empty CX2Network
+     */
+    static createEmpty(): CX2Network;
+    /**
+     * Create CX2Network from raw JSON data
+     */
+    static fromJSON(json: string | object): CX2Network;
+    /**
+     * Create CX2Network from NetworkSummary (for compatibility)
+     */
+    static fromNetworkSummary(summary: NetworkSummaryV3): CX2Network;
+    /**
+     * Add a node to the network
+     */
+    addNode(id: number, attributes?: Record<string, any>): CX2Node;
+    /**
+     * Add an edge to the network
+     */
+    addEdge(id: number, sourceId: number, targetId: number, attributes?: Record<string, any>): CX2Edge;
+    /**
+     * Add an individual node attribute
+     */
+    addNodeAttribute(nodeId: number, attributeName: string, value: any): void;
+    /**
+     * Add edge attributes (bulk)
+     */
+    addEdgeAttribute(edgeId: number, attributeName: string, value: any): void;
+    /**
+     * Set node coordinates
+     */
+    setNodeCoordinates(nodeId: number, x: number, y: number, z?: number): void;
+    /**
+     * Get node by ID
+     */
+    getNode(id: number): CX2Node | undefined;
+    /**
+     * Get edge by ID
+     */
+    getEdge(id: number): CX2Edge | undefined;
+    /**
+     * Get all nodes
+     */
+    getNodes(): CX2Node[];
+    /**
+     * Get all edges
+     */
+    getEdges(): CX2Edge[];
+    /**
+     * Get node count
+     */
+    getNodeCount(): number;
+    /**
+     * Get edge count
+     */
+    getEdgeCount(): number;
+    /**
+     * Get network name from attributes
+     */
+    getNetworkName(): string | undefined;
+    /**
+     * Set network name
+     */
+    setNetworkName(name: string): void;
+    /**
+     * Get network attribute by key
+     */
+    getNetworkAttribute(key: string): any;
+    /**
+     * Set network attribute
+     */
+    setNetworkAttribute(key: string, value: any): void;
+    /**
+     * Validate the CX2 network structure
+     */
+    validate(): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Convert to JSON string
+     */
+    toJSON(): string;
+    /**
+     * Create a deep copy of the network
+     */
+    clone(): CX2Network;
+    /**
+     * Get basic statistics about the network
+     */
+    getStatistics(): {
+        nodeCount: number;
+        edgeCount: number;
+        hasCoordinates: boolean;
+        hasVisualProperties: boolean;
+    };
+    /**
+     * Ensure required metadata is present
+     */
+    private ensureRequiredMetadata;
+    /**
+     * Update node count in metadata
+     */
+    private updateNodeCount;
+    /**
+     * Update edge count in metadata
+     */
+    private updateEdgeCount;
+}
+
+/**
+ * NetworkServiceV3 - NDEx API v3 network operations
+ * Handles modern v3 endpoints with native CX2 support
+ */
+declare class NetworkServiceV3 {
+    private http;
+    constructor(http: HTTPService);
+    /**
+     * Get network summary by UUID
+     */
+    getNetworkSummary(networkUUID: string, options?: AccessParams): Promise<NetworkSummaryV3>;
+    /**
+     * Get raw network in CX2 format (native V3)
+     *
+     * Returns raw CX2 data which may contain fragmented aspects that need to be assembled
+     * into a complete CX2 network model for proper usage. The returned data follows the
+     * CX2 specification but may have aspects split across multiple fragments.
+     * For a fully assembled network object with utility methods, use getNetworkAsCX2Object() instead.
+     *
+     * @param networkUUID - The UUID of the network to retrieve
+     * @param options - Access options including optional access key
+     * @returns Promise resolving to raw CX2 network data that may be fragmented
+     */
+    getRawCX2Network(networkUUID: string, options?: AccessParams): Promise<CX2Network$1>;
+    /**
+     * Create network DOI
+     *
+     * @param networkUUID - The UUID of the network to create a DOI for
+     * @param key - DOI creation key
+     * @param email - Email address for DOI registration
+     * @returns Promise resolving to a confirmation message string from the server
+     */
+    createNetworkDOI(networkUUID: string, key: string, email: string): Promise<string>;
+    /**
+     * Get attributes of selected nodes
+     *
+     * Retrieves specific attributes for a set of nodes in a network. The server will return
+     * a 404 error if the network has no attributes on nodes.
+     *
+     * @param networkUUID - The UUID of the network
+     * @param nodeSelection - Object containing node IDs and attribute names to retrieve
+     * @param nodeSelection.ids - Array of node IDs (long numbers) to get attributes for
+     * @param nodeSelection.attributeNames - Array of attribute names to retrieve
+     * @param options - Access options including optional access key
+     * @returns Promise resolving to a JSON object where keys are stringified node IDs
+     *          and values are the selected attributes for that node
+     * @throws {404} When the network has no attributes on nodes
+     */
+    getAttributesOfSelectedNodes(networkUUID: string, nodeSelection: {
+        ids: number[];
+        attributeNames: string[];
+    }, options?: AccessParams): Promise<Record<string, any>>;
+    /**
+   * Get network summaries by UUIDs using V3 API (migrated from original NDEx.js)
+   *
+   * Retrieves network summaries for multiple networks in a single batch request using V3 API.
+   * Uses the V3 API batch endpoint with format parameter support.
+   *
+   * @param uuidList - Array of network UUIDs to retrieve summaries for
+   * @param accessKey - Optional access key for private networks
+   * @param format - Summary format ("FULL" by default, can be "BASIC" or other supported formats)
+   * @returns Promise resolving to array of V3 network summaries
+   */
+    getNetworkSummariesV3ByUUIDs(uuidList: string[], accessKey?: string, format?: string): Promise<NetworkSummaryV3[]>;
+    /**
+     * Search networks with V3 enhanced features
+     */
+    searchNetworks(searchParams?: SearchParameters): Promise<SearchResult>;
+    /**
+     * Get network as CX2Network object with utilities
+     */
+    getNetworkAsCX2Object(networkUUID: string, options?: AccessParams): Promise<CX2Network>;
+    /**
+     * Create new network from CX2
+     */
+    createNetworkFromCX2(cx2Data: CX2Network$1 | CX2Network, options?: {
+        visibility?: 'PUBLIC' | 'PRIVATE';
+        name?: string;
+    }): Promise<{
+        uuid: string;
+    }>;
+    /**
+     * Update network with CX2 data
+     */
+    updateNetworkCX2(networkUUID: string, cx2Data: CX2Network$1 | CX2Network): Promise<void>;
+    /**
+     * Upload network file (CX2, CX, or other formats)
+     */
+    uploadNetworkFile(file: File | Blob | string, options?: {
+        filename?: string;
+        visibility?: 'PUBLIC' | 'PRIVATE';
+        name?: string;
+        onProgress?: (progress: number) => void;
+    }): Promise<{
+        uuid: string;
+    }>;
+    /**
+     * Get network metadata (V3 enhanced)
+     */
+    getNetworkMetadata(networkUUID: string): Promise<any>;
+    /**
+     * Update network metadata
+     */
+    updateNetworkMetadata(networkUUID: string, metadata: Record<string, any>): Promise<void>;
+    /**
+     * Get network aspect (specific CX2 aspect)
+     */
+    getNetworkAspect(networkUUID: string, aspectName: string, options?: AccessParams): Promise<any>;
+}
+
+/**
+ * NetworkServiceV2 - NDEx API v2 network operations
+ * Handles legacy v2 endpoints with modern TypeScript interface
+ */
+declare class NetworkServiceV2 {
+    private http;
+    constructor(http: HTTPService);
+    /**
+     * Get raw network in CX1 format
+     *
+     * Returns raw CX1 data as an array of aspects. This data may contain fragmented aspects
+     * that need to be assembled into a complete CX1 network model for proper usage.
+     * For a fully assembled network object, consider using getNetworkAsCX2Object() instead.
+     *
+     * @param networkUUID - The UUID of the network to retrieve
+     * @param options - Access options including optional access key
+     * @returns Promise resolving to raw CX1 data as an array of aspects
+     */
+    getRawCX1Network(networkUUID: string, options?: AccessParams): Promise<any[]>;
+    /**
+     * Get network summary by UUID
+     */
+    getNetworkSummary(networkUUID: string, options?: AccessParams): Promise<NetworkSummaryV2>;
+    /**
+    * Copy network
+    *
+    * Creates a copy of an existing network using the server's copy endpoint.
+    * The copied network will have the same content but will be assigned a new UUID
+    * and will be owned by the authenticated user.
+    *
+    * @param networkUUID - The UUID of the network to copy
+    * @returns Promise resolving to the URL of the cloned CX1 network
+    */
+    copyNetwork(networkUUID: string): Promise<string>;
+    /**
+     * Search networks (migrated from original NDEx.js)
+     *
+     * Searches networks using POST request with search parameters in the request body.
+     * This implementation matches the original NDEx.js searchNetworks function.
+     *
+     * @param searchTerms - Search string to find networks
+     * @param start - Starting offset for pagination (optional)
+     * @param size - Maximum number of results to return (optional)
+     * @param optionalParameters - Additional search filters
+     * @param optionalParameters.permission - Filter by permission level
+     * @param optionalParameters.includeGroups - Whether to include group networks
+     * @param optionalParameters.accountName - Filter by account name
+     * @returns Promise resolving to search results
+     */
+    searchNetworks(searchTerms: string, start?: number, size?: number, optionalParameters?: {
+        permission?: string;
+        includeGroups?: boolean;
+        accountName?: string;
+    }): Promise<any>;
+    /**
+     * Create new network from raw CX1 data
+     *
+     * Creates a new network in NDEx from raw CX1 network data. This method handles
+     * the server response parsing to extract the network UUID from the location header.
+     *
+     * @param rawCX - Raw CX1 network data as an array of aspects
+     * @param options - Optional options for network creation (visibility settings)
+     * @returns Promise resolving to the UUID string of the newly created network
+     */
+    createNetworkFromRawCX1(rawCX: any[], options?: {
+        visibility?: 'PUBLIC' | 'PRIVATE';
+    }): Promise<string>;
+    /**
+     * Update network from raw CX1 data
+     *
+     * Updates an existing network in NDEx with new raw CX1 network data.
+     * This completely replaces the network content with the provided CX1 data.
+     * Uses the legacy v2 endpoint format from the original NDEx.js implementation.
+     *
+     * @param networkUUID - The UUID of the network to update
+     * @param rawCX - Raw CX1 network data as an array of aspects
+     * @returns Promise resolving when the update is complete
+     */
+    updateNetworkFromRawCX1(networkUUID: string, rawCX: any[]): Promise<void>;
+    /**
+     * Delete network
+     */
+    deleteNetwork(networkUUID: string): Promise<void>;
+    /**
+     * Get network summaries by UUIDs (migrated from original NDEx.js)
+     *
+     * Retrieves network summaries for multiple networks in a single batch request.
+     * Uses the V2 API batch endpoint for efficient bulk operations.
+     *
+     * @param uuidList - Array of network UUIDs to retrieve summaries for
+     * @param accessKey - Optional access key for private networks
+     * @returns Promise resolving to array of network summaries
+     */
+    getNetworkSummariesByUUIDs(uuidList: string[], accessKey?: string): Promise<NetworkSummaryV2[]>;
+    /**
+      * Get user's networks
+      */
+    getUserNetworks(accountName: string, options?: PaginationParams): Promise<NetworkSummaryV2[]>;
+    /**
+     * Set network system properties
+     */
+    setNetworkSystemProperties(networkUUID: string, properties: Record<string, any>): Promise<void>;
+    /**
+     * Get network permissions
+     */
+    getNetworkPermissions(networkUUID: string): Promise<NetworkPermission[]>;
+    /**
+     * Set network permissions
+     */
+    setNetworkPermissions(networkUUID: string, permissions: NetworkPermission[]): Promise<void>;
+    /**
+     * Grant network permission to user
+     */
+    grantNetworkPermission(networkUUID: string, userUUID: string, permission: 'READ' | 'WRITE' | 'ADMIN'): Promise<void>;
+    /**
+     * Revoke network permission from user
+     */
+    revokeNetworkPermission(networkUUID: string, userUUID: string): Promise<void>;
+    /**
+     * Get network profile (additional metadata)
+     */
+    getNetworkProfile(networkUUID: string): Promise<any>;
+    /**
+     * Set network profile
+     */
+    setNetworkProfile(networkUUID: string, profile: any): Promise<void>;
+    /**
+     * Make network public
+     */
+    makeNetworkPublic(networkUUID: string): Promise<void>;
+    /**
+     * Make network private
+     */
+    makeNetworkPrivate(networkUUID: string): Promise<void>;
+    /**
+     * Get network sample (if available)
+     */
+    getNetworkSample(networkUUID: string, options?: AccessParams): Promise<any[]>;
+    /**
+     * Get network metadata (migrated from original NDEx.js)
+     *
+     * Retrieves metadata information about network aspects including element counts,
+     * versions, and ID counters for each aspect in the network. This provides
+     * an overview of the network's structure and content organization.
+     *
+     * @param networkUUID - The UUID of the network to get metadata for
+     * @param accessKey - Optional access key for private networks
+     * @returns Promise resolving to metadata containing aspect information
+     * @example
+     * ```typescript
+     * const metadata = await networkService.getMetaData('network-uuid');
+     * // Returns: { metaData: [{ name: 'nodes', elementCount: 330, version: '1.0' }, ...] }
+     * ```
+     */
+    getMetaData(networkUUID: string, accessKey?: string): Promise<CX1MetaDataResponse>;
+    /**
+     * Get network access key (migrated from original NDEx.js)
+     *
+     * Retrieves the current access key for a network. Access keys allow
+     * users to share private networks without requiring individual permissions.
+     *
+     * @param networkUUID - The UUID of the network to get access key for
+     * @returns Promise resolving to access key response object
+     *
+     * @example
+     * ```typescript
+     * const response = await networkService.getAccessKey('network-uuid');
+     * console.log(response.accessKey); // "acialdfeoa03430023" or null
+     * ```
+     */
+    getAccessKey(networkUUID: string): Promise<AccessKeyResponse>;
+    /**
+     * Update network access key (migrated from original NDEx.js)
+     *
+     * Enables or disables the access key for a network. When enabled, creates
+     * a new access key that can be shared. When disabled, invalidates the
+     * current access key.
+     *
+     * @param networkUUID - The UUID of the network to update access key for
+     * @param action - Action to perform: 'enable' creates/updates key, 'disable' removes it
+     * @returns Promise resolving to access key response (accessKey will be null when disabled)
+     *
+     * @example
+     * ```typescript
+     * // Enable access key
+     * const enabled = await networkService.updateAccessKey('network-uuid', 'enable');
+     * console.log(enabled.accessKey); // "new-access-key-string"
+     *
+     * // Disable access key
+     * const disabled = await networkService.updateAccessKey('network-uuid', 'disable');
+     * console.log(disabled.accessKey); // null
+     * ```
+     */
+    updateAccessKey(networkUUID: string, action: AccessKeyAction): Promise<AccessKeyResponse>;
+}
+
+/**
+ * UnifiedNetworkService - Provides access to both V2/V3 network services
+ * Allows individual function calls to choose between v2 and v3 APIs
+ */
+declare class UnifiedNetworkService {
+    private http;
+    private v2Service;
+    private v3Service;
+    constructor(http: HTTPService);
+    /**
+     * Get network summary using specified API version
+     */
+    getNetworkSummary(networkUUID: string, options?: AccessParams): Promise<NetworkSummaryV3>;
+    /**
+     * Search networks using specified API version
+     * NOTE: This method is temporarily commented out as the V2 searchNetworks
+     * signature has been migrated from NDEx.js and needs separate integration
+     */
+    /**
+     * Get network in CX1 format (V2 API)
+     */
+    getRawCX1Network(networkUUID: string, options?: AccessParams): Promise<any[]>;
+    /**
+     * Get network in CX2 format (V3 API)
+     */
+    getRawCX2Network(networkUUID: string, options?: AccessParams): Promise<CX2Network$1>;
+    /**
+     * Delete network
+     */
+    deleteNetwork(networkUUID: string): Promise<void>;
+    /**
+     * Create network DOI
+     *
+     * @param networkUUID - The UUID of the network to create a DOI for
+     * @param key - DOI creation key
+     * @param email - Email address for DOI registration
+     * @returns Promise resolving to a confirmation message string from the server
+     */
+    createNetworkDOI(networkUUID: string, key: string, email: string): Promise<string>;
+    /**
+     * Get attributes of selected nodes
+     *
+     * Retrieves specific attributes for a set of nodes in a network. The server will return
+     * a 404 error if the network has no attributes on nodes.
+     *
+     * @param networkUUID - The UUID of the network
+     * @param nodeSelection - Object containing node IDs and attribute names to retrieve
+     * @param nodeSelection.ids - Array of node IDs (long numbers) to get attributes for
+     * @param nodeSelection.attributeNames - Array of attribute names to retrieve
+     * @param options - Access options including optional access key
+     * @returns Promise resolving to a JSON object where keys are stringified node IDs
+     *          and values are the selected attributes for that node
+     * @throws {404} When the network has no attributes on nodes
+     */
+    getAttributesOfSelectedNodes(networkUUID: string, nodeSelection: {
+        ids: number[];
+        attributeNames: string[];
+    }, options?: AccessParams): Promise<Record<string, any>>;
+    /**
+     * Neighborhood query (migrated from original NDEx.js)
+     *
+     * Performs a neighborhood search within a network, returning nodes and edges
+     * within the specified search depth from nodes matching the search terms.
+     * Can return either raw CX1 or CX2 format based on outputCX2 parameter.
+     *
+     * @param networkUUID - The UUID of the network to search
+     * @param searchTerms - Search string to find starting nodes
+     * @param saveResult - Whether to save the query result as a new network
+     * @param parameters - Additional query parameters
+     * @param parameters.searchDepth - How many hops to search (default: 1)
+     * @param parameters.edgeLimit - Maximum number of edges to return
+     * @param parameters.errorWhenLimitIsOver - Throw error if edge limit exceeded
+     * @param parameters.directOnly - Only include direct connections
+     * @param parameters.nodeIds - Specific node IDs to start search from
+     * @param outputCX2 - If true, return CX2 format via V3 API; if false, return CX1 format via V2 API
+     * @returns Promise resolving to raw CX1 or CX2 network data
+     */
+    neighborhoodQuery(networkUUID: string, searchTerms: string, saveResult?: boolean, parameters?: {
+        searchDepth?: number;
+        edgeLimit?: number;
+        errorWhenLimitIsOver?: boolean;
+        directOnly?: boolean;
+        nodeIds?: number[];
+    }, outputCX2?: boolean): Promise<any[] | CX2Network$1>;
+    /**
+     * Interconnect query (migrated from original NDEx.js)
+     *
+     * Finds connections between nodes matching the search terms within a network.
+     * Returns the interconnected subnetwork as either raw CX1 or CX2 format.
+     * Can return either raw CX1 or CX2 format based on outputCX2 parameter.
+     *
+     * @param networkUUID - The UUID of the network to search
+     * @param searchTerms - Search string to find nodes to interconnect
+     * @param saveResult - Whether to save the query result as a new network
+     * @param parameters - Additional query parameters
+     * @param parameters.edgeLimit - Maximum number of edges to return
+     * @param parameters.errorWhenLimitIsOver - Throw error if edge limit exceeded
+     * @param parameters.nodeIds - Specific node IDs to find connections between
+     * @param outputCX2 - If true, return CX2 format via V3 API; if false, return CX1 format via V2 API
+     * @returns Promise resolving to raw CX1 or CX2 network data
+     */
+    interConnectQuery(networkUUID: string, searchTerms: string, saveResult?: boolean, parameters?: {
+        edgeLimit?: number;
+        errorWhenLimitIsOver?: boolean;
+        nodeIds?: number[];
+    }, outputCX2?: boolean): Promise<any[] | CX2Network$1>;
+    /**
+     * Get network permissions by UUIDs (migrated from original NDEx.js)
+     *
+     * Retrieves network permissions for multiple networks in a single batch request.
+     * Uses the V2 API batch endpoint to efficiently get permission information.
+     *
+     * @param uuidList - Array of network UUIDs to retrieve permissions for
+     * @returns Promise resolving to permission information for the specified networks
+     */
+    getNetworkPermissionsByUUIDs(uuidList: string[]): Promise<any[]>;
+    /**
+     * Export networks (migrated from original NDEx.js)
+     *
+     * Creates an export job for networks using the V2 batch export endpoint.
+     * This allows exporting multiple networks in various formats.
+     *
+     * @param exportJob - Export job configuration specifying networks and format
+     * @returns Promise resolving to export job result
+     */
+    exportNetworks(exportJob: any): Promise<any>;
+    /**
+     * Move networks to folder (migrated from original NDEx.js)
+     *
+     * Moves multiple networks to a specified folder using the V3 API.
+     * This is a V3-specific feature for organizing networks in folders.
+     *
+     * @param networkIds - Array of network IDs to move
+     * @param folderId - Target folder ID to move networks to
+     * @returns Promise resolving when networks are moved
+     */
+    moveNetworks(networkIds: string[], folderId: string): Promise<any>;
+    /**
+     * Set networks visibility (migrated from original NDEx.js)
+     *
+     * Changes visibility settings for multiple networks using the V3 API.
+     * Requires proper file validation to ensure data integrity.
+     *
+     * @param files - Object containing files with their types (must have 'files' property)
+     * @param visibility - Visibility setting (e.g., 'PUBLIC', 'PRIVATE')
+     * @returns Promise resolving when visibility is updated
+     */
+    setNetworksVisibility(files: {
+        files: Record<string, 'NETWORK' | 'FOLDER' | 'SHORTCUT'>;
+    }, visibility: string): Promise<any>;
+    /**
+     * Get random edges from network (migrated from original NDEx.js)
+     *
+     * Retrieves a random sample of edges from a network using the V3 API.
+     * This is useful for previewing large networks or sampling edge data.
+     *
+     * @param networkUUID - The UUID of the network to get edges from
+     * @param limit - Number of random edges to retrieve (must be greater than 0)
+     * @param accessKey - Optional access key for private networks
+     * @returns Promise resolving to array of CX2Edge objects
+     * @throws Error if limit is less than or equal to 0
+     */
+    getRandomEdges(networkUUID: string, limit: number, accessKey?: string): Promise<CX2Edge[]>;
+    /**
+     * Validate share data format (helper method for file operations)
+     *
+     * Validates the structure and content of file data used in sharing operations.
+     * Ensures proper UUID format and valid file types.
+     *
+     * @param data - Data object to validate (must contain 'files' property)
+     * @throws Error if validation fails
+     */
+    private validateShareData;
+    /**
+     * Get aspect elements (migrated from original NDEx.js)
+     *
+     * Retrieves elements from a specific aspect of a network using the V3 API.
+     * This function can be used to get nodes, edges, or other aspect data
+     * with optional size limiting and access key support for private networks.
+     *
+     * @param networkUUID - The UUID of the network to get aspect elements from
+     * @param aspectName - Name of the aspect to retrieve (e.g., 'nodes', 'edges', 'networkAttributes')
+     * @param limit - Optional maximum number of elements to return
+     * @param accessKey - Optional access key for private networks
+     * @returns Promise resolving to array of aspect elements
+     * @example
+     * ```typescript
+     * // Get first 100 nodes from a network
+     * const nodes = await client.networks.getAspectElements('network-uuid', 'nodes', 100);
+     *
+     * // Get all edges from a network
+     * const edges = await client.networks.getAspectElements('network-uuid', 'edges');
+     * ```
+     */
+    getAspectElements(networkUUID: string, aspectName: string, limit?: number, accessKey?: string): Promise<any[]>;
+    /**
+     * Get filtered edges (migrated from original NDEx.js)
+     *
+     * Retrieves edges from a network that match specific filtering criteria on a column value.
+     * The function supports both CX1 and CX2 formats based on the format parameter, with CX2
+     * being the default format used by the server.
+     *
+     * @param networkUUID - The UUID of the network to get filtered edges from
+     * @param columnName - Name of the edge attribute column to filter on
+     * @param valueString - Value to filter by (converted to string for comparison)
+     * @param operator - Filtering operation: '>' | '<' | '=' | '!='
+     * @param limit - Optional maximum number of edges to return (default: -1 = all matching edges)
+     * @param order - Optional sort order for edges before applying limit: 'asc' | 'desc' (default: 'desc')
+     * @param format - Optional output format: 'cx' | 'cx2' (default: 'cx2')
+     * @param accessKey - Optional access key for private networks
+     * @returns Promise resolving to array of edges in the specified format
+     *
+     * @example
+     * ```typescript
+     * // Get edges with weight > 0.5 in CX2 format (default)
+     * const cx2Edges = await client.networks.getFilteredEdges(
+     *   'network-uuid', 'weight', '0.5', '>'
+     * );
+     *
+     * // Get top 10 edges with highest score in CX1 format
+     * const cx1Edges = await client.networks.getFilteredEdges(
+     *   'network-uuid', 'score', '0', '>', 10, 'desc', 'cx'
+     * );
+     *
+     * // Get edges where interaction equals 'pp'
+     * const ppEdges = await client.networks.getFilteredEdges(
+     *   'network-uuid', 'interaction', 'pp', '=', undefined, undefined, 'cx2'
+     * );
+     * ```
+     */
+    getFilteredEdges(networkUUID: string, columnName: string, valueString: string, operator: '>' | '<' | '=' | '!=', limit?: number, order?: 'asc' | 'desc', format?: 'cx' | 'cx2', accessKey?: string): Promise<CX2Edge[] | CX1Edge[]>;
+    /**
+     * Get CX2 metadata (migrated from original NDEx.js)
+     *
+     * Retrieves metadata information for all aspects in a CX2 network format.
+     * This function provides aspect metadata including element counts for each
+     * aspect in the network using the V3 API.
+     *
+     * @param networkUUID - The UUID of the network to get CX2 metadata for
+     * @param accessKey - Optional access key for private networks
+     * @returns Promise resolving to array of CX2MetaData objects
+     *
+     * @example
+     * ```typescript
+     * // Get CX2 metadata for a network
+     * const metaData = await client.networks.getCX2MetaData('network-uuid');
+     * console.log(metaData); // [{ name: 'nodes', elementCount: 100 }, { name: 'edges', elementCount: 150 }]
+     *
+     * // Get CX2 metadata for a private network
+     * const privateMetaData = await client.networks.getCX2MetaData('private-network-uuid', 'access-key');
+     * ```
+     */
+    getCX2MetaData(networkUUID: string, accessKey?: string): Promise<CX2MetaData[]>;
+    /**
+     * Create network from raw CX2 data (migrated from original NDEx.js)
+     *
+     * Creates a new network in NDEx from raw CX2 network data. This is an unstable function
+     * for uploading CX2 format networks directly to NDEx using the V3 API. The function
+     * extracts the network UUID from the response location header.
+     *
+     * @param rawCX2 - Raw CX2 network data as an object or CX2Network instance
+     * @param makePublic - Whether to make the network public (default: false = private)
+     * @returns Promise resolving to an object containing the UUID of the created network
+     *
+     * @example
+     * ```typescript
+     * // Create private network from raw CX2 data
+     * const result = await client.networks.createNetworkFromRawCX2(cx2Data);
+     * console.log(result.uuid); // "12345678-1234-1234-1234-123456789abc"
+     *
+     * // Create public network from raw CX2 data
+     * const publicResult = await client.networks.createNetworkFromRawCX2(cx2Data, true);
+     * console.log(publicResult.uuid);
+     * ```
+     */
+    createNetworkFromRawCX2(rawCX2: CX2Network$1 | any, makePublic?: boolean): Promise<{
+        uuid: string;
+    }>;
+    /**
+     * Update network from raw CX2 data (migrated from original NDEx.js)
+     *
+     * Updates an existing network with new raw CX2 data using the V3 API.
+     * This function replaces the entire network content with the provided CX2 data.
+     *
+     * @param networkUUID - The UUID of the network to update
+     * @param rawCX2 - Raw CX2 network data as an object or CX2Network instance
+     * @returns Promise resolving when the network update is complete
+     *
+     * @example
+     * ```typescript
+     * // Update existing network with new CX2 data
+     * await client.networks.updateNetworkFromRawCX2('network-uuid', updatedCx2Data);
+     * ```
+     */
+    updateNetworkFromRawCX2(networkUUID: string, rawCX2: CX2Network$1 | any): Promise<void>;
+    /**
+     * Access to underlying service instances for advanced usage
+     */
+    get v2(): NetworkServiceV2;
+    get v3(): NetworkServiceV3;
+}
+
+interface ShareData {
+    files: Record<string, 'NETWORK' | 'FOLDER' | 'SHORTCUT'>;
+}
+interface MemberData {
+    members: Record<string, 'READ' | 'WRITE'>;
+}
+/**
+ * FilesService - NDEx file operations and task management
+ * Handles file uploads, downloads, exports, and asynchronous task tracking
+ */
+declare class FilesService {
+    private http;
+    constructor(http: HTTPService);
+    /**
+     * Copy a file to a different location
+     * @param fromUuid - Source file UUID
+     * @param toPath - Target path
+     * @param type - File type (NETWORK, FOLDER, SHORTCUT)
+     * @param accessKey - Optional access key for protected files
+     */
+    copyFile(fromUuid: string, toPath: string, type: string, accessKey?: string): Promise<any>;
+    /** Get file count statistics for the current user */
+    getCount(): Promise<any>;
+    /** Get files in the trash for the current user */
+    getTrash(): Promise<any>;
+    /** Permanently delete all files in trash */
+    emptyTrash(): Promise<any>;
+    /**
+     * Permanently delete a file from trash
+     * @param fileId - File UUID to permanently delete
+     */
+    permanentlyDeleteFile(fileId: string): Promise<any>;
+    /**
+     * Restore files from trash
+     * @param networkIds - Array of network UUIDs to restore
+     * @param folderIds - Array of folder UUIDs to restore
+     * @param shortcutIds - Array of shortcut UUIDs to restore
+     */
+    restoreFile(networkIds: string[], folderIds: string[], shortcutIds: string[]): Promise<any>;
+    private _validateShareData;
+    private _validateMemberData;
+    updateMember(files: ShareData['files'], members: MemberData['members']): Promise<any>;
+    listMembers(files: any): Promise<any>;
+    transferOwnership(files: ShareData['files'], newOwner: string): Promise<any>;
+    listShares(limit?: number): Promise<any>;
+    share(files: ShareData['files']): Promise<any>;
+    unshare(files: ShareData['files']): Promise<any>;
+    getFolders(limit?: number): Promise<any>;
+    createFolder(name: string, parentFolderId?: string): Promise<any>;
+    getFolder(folderId: string, accessKey?: string): Promise<any>;
+    updateFolder(folderId: string, name: string, parentFolderId?: string): Promise<any>;
+    deleteFolder(folderId: string): Promise<any>;
+    getFolderCount(folderId: string, accessKey?: string): Promise<any>;
+    getFolderList(folderId: string, accessKey?: string, format?: string, type?: string): Promise<any>;
+    getShortcuts(limit?: number): Promise<any>;
+    createShortcut(name: string, parentFolderId?: string, targetId?: string, targetType?: string): Promise<any>;
+    getShortcut(shortcutId: string, accessKey?: string): Promise<any>;
+    updateShortcut(shortcutId: string, name: string, parentFolderId?: string, targetId?: string, targetType?: string): Promise<any>;
+    deleteShortcut(shortcutId: string): Promise<any>;
+}
+
+/**
+ * WorkspaceService - NDEx CyWeb workspace operations
+ *
+ * Provides methods for managing CyWeb workspaces including creation, retrieval,
+ * updates, and deletion of workspaces and their associated networks.
+ * All workspace operations use the V3 API.
+ */
+declare class WorkspaceService {
+    private http;
+    constructor(http: HTTPService);
+    /**
+     * Create a new CyWeb workspace (migrated from original NDEx.js)
+     *
+     * Creates a new workspace with the specified workspace data.
+     *
+     * @param workspace - The workspace object to create
+     * @returns Promise resolving to the response from the server (typically contains workspace location)
+     *
+     * @example
+     * ```typescript
+     * const workspaceData = {
+     *   name: "My Workspace",
+     *   description: "A sample workspace",
+     *   networkIds: []
+     * };
+     * const response = await client.workspace.createCyWebWorkspace(workspaceData);
+     * ```
+     */
+    createCyWebWorkspace(workspace: CyWebWorkspace): Promise<string>;
+    /**
+     * Get a CyWeb workspace by ID (migrated from original NDEx.js)
+     *
+     * Retrieves a workspace and its details by workspace ID.
+     *
+     * @param workspaceId - The UUID of the workspace to retrieve
+     * @returns Promise resolving to the workspace object
+     *
+     * @example
+     * ```typescript
+     * const workspace = await client.workspace.getCyWebWorkspace('workspace-uuid');
+     * console.log(workspace.name);
+     * ```
+     */
+    getCyWebWorkspace(workspaceId: string): Promise<CyWebWorkspace>;
+    /**
+     * Delete a CyWeb workspace (migrated from original NDEx.js)
+     *
+     * Deletes the specified workspace permanently.
+     *
+     * @param workspaceId - The UUID of the workspace to delete
+     * @returns Promise resolving when the workspace is deleted
+     *
+     * @example
+     * ```typescript
+     * await client.workspace.deleteCyWebWorkspace('workspace-uuid');
+     * ```
+     */
+    deleteCyWebWorkspace(workspaceId: string): Promise<void>;
+    /**
+     * Update a CyWeb workspace (migrated from original NDEx.js)
+     *
+     * Updates a workspace with new data, replacing the entire workspace object.
+     *
+     * @param workspaceId - The UUID of the workspace to update
+     * @param workspaceObj - The updated workspace object
+     * @returns Promise resolving when the workspace is updated
+     *
+     * @example
+     * ```typescript
+     * const updatedWorkspace = {
+     *   name: "Updated Workspace Name",
+     *   description: "Updated description",
+     *   networkIds: ["network-uuid-1", "network-uuid-2"]
+     * };
+     * await client.workspace.updateCyWebWorkspace('workspace-uuid', updatedWorkspace);
+     * ```
+     */
+    updateCyWebWorkspace(workspaceId: string, workspaceObj: CyWebWorkspace): Promise<void>;
+    /**
+     * Update CyWeb workspace name (migrated from original NDEx.js)
+     *
+     * Updates only the name of a workspace.
+     *
+     * @param workspaceId - The UUID of the workspace to update
+     * @param newName - The new name for the workspace
+     * @returns Promise resolving when the workspace name is updated
+     *
+     * @example
+     * ```typescript
+     * await client.workspace.updateCyWebWorkspaceName('workspace-uuid', 'New Workspace Name');
+     * ```
+     */
+    updateCyWebWorkspaceName(workspaceId: string, newName: string): Promise<void>;
+    /**
+     * Update CyWeb workspace networks (migrated from original NDEx.js)
+     *
+     * Updates the list of network IDs associated with a workspace.
+     *
+     * @param workspaceId - The UUID of the workspace to update
+     * @param networkIds - Array of network UUIDs to associate with the workspace
+     * @returns Promise resolving when the workspace networks are updated
+     *
+     * @example
+     * ```typescript
+     * const networkIds = ['network-uuid-1', 'network-uuid-2', 'network-uuid-3'];
+     * await client.workspace.updateCyWebWorkspaceNetworks('workspace-uuid', networkIds);
+     * ```
+     */
+    updateCyWebWorkspaceNetworks(workspaceId: string, networkIds: string[]): Promise<void>;
+    /**
+     * Get user's CyWeb workspaces (migrated from original NDEx.js)
+     *
+     * Retrieves all workspaces belonging to the currently authenticated user.
+     * Requires authentication.
+     *
+     * @returns Promise resolving to array of workspace objects
+     *
+     * @example
+     * ```typescript
+     * const workspaces = await client.workspace.getUserCyWebWorkspaces();
+     * workspaces.forEach(workspace => {
+     *   console.log(`Workspace: ${workspace.name}`);
+     * });
+     * ```
+     */
+    getUserCyWebWorkspaces(): Promise<CyWebWorkspace[]>;
+}
+
+/**
+ * UserService - NDEx user-related operations
+ * Handles authentication, user management, and user workspace operations
+ */
+declare class UserService {
+    private http;
+    constructor(http: HTTPService);
+    /**
+     * Get authenticated user (equivalent to getSignedInUser from legacy client)
+     * Returns the current signed-in user object from NDEx server
+     *
+     * For basic authentication: Gets the current user using the /user endpoint
+     * For OAuth authentication: Uses the /users/signin endpoint with ID token
+     *
+     * @returns The authenticated user object
+     * @note When authenticating with OAuth ID token, if a user with matching email
+     *       doesn't exist on the server, this function will automatically create
+     *       that user and return the newly created user object.
+     */
+    authenticate(): Promise<NDExUser>;
+    /**
+     * Get current user profile (equivalent to getSignedInUser from legacy client)
+     * Returns the current signed-in user object from NDEx server
+     *
+     * Uses the /user endpoint with {valid: true} parameter for both basic and OAuth authentication.
+     * Unlike authenticate(), this function will NOT automatically create a user account for OAuth.
+     * If the OAuth ID token doesn't match an existing user, it will return an unauthorized error.
+     *
+     * @returns The current user object
+     * @note This function requires existing authentication and will not create new users
+     */
+    getCurrentUser(): Promise<NDExUser>;
+    /**
+     * Update current user profile
+     * Uses the UUID from the userUpdate object and server validates against authenticated user
+     */
+    updateCurrentUser(userUpdate: Partial<NDExUser>): Promise<void>;
+    /**
+     * Request password reset
+     */
+    requestPasswordReset(email: string): Promise<void>;
+    /**
+     * Reset password with user UUID (server validates UUID matches authenticated user)
+     * @param userUUID - User UUID (must match authenticated user)
+     * @param newPassword - New password as plain text
+     */
+    resetPassword(userUUID: string, newPassword: string): Promise<void>;
+    /**
+     * Get user by UUID
+     */
+    getUser(userUUID: string): Promise<NDExUser>;
+    /**
+     * Get user by account name or email (matches server getUserByAccountNameOrAuthenticatUser)
+     * @param searchBy - Search criteria - either by username OR by email, but not both
+     * @returns User object matching the search criteria
+     * @note If both username and email are provided, only username will be used
+     */
+    getUserByNameOrEmail(searchBy: {
+        username: string;
+    } | {
+        email: string;
+    }): Promise<NDExUser>;
+    /**
+     * Get multiple users by their UUIDs (batch operation)
+     * @param uuidList - Array of user UUIDs to fetch
+     * @returns Array of user objects corresponding to the provided UUIDs
+     */
+    getUsersByUUIDs(uuidList: string[]): Promise<NDExUser[]>;
+    /**
+     * Search users (equivalent to searchUsers from legacy client)
+     * @param searchTerms - Search string to find users
+     * @param start - Starting offset for pagination (optional)
+     * @param size - Maximum number of results to return (optional)
+     * @returns Array of users matching the search criteria
+     */
+    searchUsers(searchTerms: string, start?: number, size?: number): Promise<NDExUser[]>;
+    /**
+     * Get networks for a user's account page (equivalent to getAccountPageNetworks from legacy client)
+     *
+     * @param userUUID - User UUID to get networks for
+     * @param offset - Starting offset for pagination (optional)
+     * @param limit - Maximum number of networks to return (optional)
+     * @returns Array of V2 network summaries for the specified user
+     * @note This function requires authentication. The auth attribute must be set in the client configuration.
+     */
+    getAccountPageNetworks(userUUID: string, offset?: number, limit?: number): Promise<NetworkSummaryV2[]>;
+    /**
+     * Delete user account (server validates userid matches authenticated user)
+     * @param userUUID - User UUID to delete (must match authenticated user)
+     * @note This function requires authentication. The auth attribute must be set in the client configuration.
+     * @note The userUUID parameter must be the UUID of the currently authenticated user. The server will validate this.
+     */
+    deleteUserAccount(userUUID: string): Promise<void>;
+}
+
+/**
+ * AdminService - NDEx admin operations
+ * Handles system administration and user management for admin users
+ */
+declare class AdminService {
+    private http;
+    constructor(http: HTTPService);
+}
+
+/**
+ * CyNDEx Service - Cytoscape-NDEx Bridge
+ *
+ * Provides seamless integration between Cytoscape desktop application and NDEx,
+ * enabling import/export of networks with support for CX and CX2 formats.
+ *
+ * This service communicates with Cytoscape via its REST API and handles NDEx
+ * authentication parameters that are passed to Cytoscape for NDEx operations.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const cyNDEx = new CyNDExService();
+ *
+ * // Configure NDEx server
+ * cyNDEx.setNDExBaseURL('https://www.ndexbio.org');
+ *
+ * // Set authentication
+ * cyNDEx.setBasicAuth('username', 'password');
+ * // or
+ * cyNDEx.setAuthToken('oauth-id-token');
+ *
+ * // Import network from NDEx to Cytoscape
+ * await cyNDEx.postNDExNetworkToCytoscape('network-uuid', 'access-key');
+ *
+ * // Export network from Cytoscape to NDEx
+ * await cyNDEx.postCytoscapeNetworkToNDEx('current');
+ *
+ * // Import CX2 data to Cytoscape
+ * await cyNDEx.postCX2NetworkToCytoscape(cx2String, 'My Network', 'My Collection');
+ * ```
+ */
+declare class CyNDExService {
+    private _port;
+    private cyRestBaseURL;
+    private ndexBaseURL;
+    private authConfig?;
+    private axiosInstance;
+    /**
+     * Create a new CyNDEx service instance
+     *
+     * @param port - Port number for Cytoscape REST API (default: 1234)
+     * @param config - Optional configuration object
+     */
+    constructor(port?: number, config?: CyNDExConfig);
+    /**
+     * Get the port number for Cytoscape REST API
+     */
+    get port(): number;
+    /**
+     * Get the base URL for Cytoscape REST API
+     */
+    static get cyRestBaseURL(): string;
+    /**
+     * Set NDEx server base URL
+     *
+     * @param ndexBaseURL - Complete base URL for NDEx server (e.g., 'https://www.ndexbio.org')
+     *                      Must include protocol (https:// or http://)
+     *
+     * @example
+     * ```typescript
+     * cyNDEx.setNDExBaseURL('https://www.ndexbio.org');
+     * cyNDEx.setNDExBaseURL('https://test.ndexbio.org');
+     * ```
+     */
+    setNDExBaseURL(ndexBaseURL: string): void;
+    /**
+     * Get the current NDEx server base URL
+     *
+     * @returns Complete NDEx server base URL
+     */
+    getNDExBaseURL(): string;
+    /**
+     * Set basic authentication credentials for NDEx operations
+     *
+     * @param username - NDEx username
+     * @param password - NDEx password
+     */
+    setBasicAuth(username: string, password: string): void;
+    /**
+     * Set OAuth ID token for NDEx operations
+     *
+     * @param idToken - OAuth ID token from authentication provider
+     */
+    setAuthToken(idToken: string): void;
+    /**
+     * Clear authentication credentials
+     */
+    clearAuth(): void;
+    /**
+     * Get the complete Cytoscape REST API URL
+     *
+     * @returns Complete URL for Cytoscape REST API
+     */
+    cyRestURL(): string;
+    /**
+     * Get authorization fields for NDEx operations
+     * These are passed as parameters to Cytoscape for NDEx authentication
+     *
+     * @private
+     * @returns Authorization parameters object
+     */
+    private getAuthFields;
+    /**
+     * Perform HTTP GET request to Cytoscape REST API
+     *
+     * @private
+     * @param url - Endpoint URL (relative to base URL)
+     * @returns Promise resolving to response data
+     */
+    private _httpGet;
+    /**
+     * Perform HTTP POST request to Cytoscape REST API
+     *
+     * @private
+     * @param url - Endpoint URL (relative to base URL)
+     * @param params - Optional query parameters
+     * @param data - Optional request body data
+     * @returns Promise resolving to response data
+     */
+    private _httpPost;
+    /**
+     * Perform HTTP PUT request to Cytoscape REST API
+     *
+     * @private
+     * @param url - Endpoint URL (relative to base URL)
+     * @param params - Optional query parameters
+     * @param data - Optional request body data
+     * @returns Promise resolving to response data
+     */
+    private _httpPut;
+    /**
+     * Get CyNDEx plugin status from Cytoscape
+     *
+     * @returns Promise resolving to CyNDEx status information
+     */
+    getCyNDExStatus(): Promise<CyNDExStatusResponse>;
+    /**
+     * Get network summary information from Cytoscape
+     *
+     * @param suid - Network SUID or 'current' for current network (default: 'current')
+     * @returns Promise resolving to network summary
+     */
+    getCytoscapeNetworkSummary(suid?: string): Promise<CytoscapeNetworkSummary>;
+    /**
+     * Import network from NDEx to Cytoscape
+     *
+     * @param uuid - NDEx network UUID
+     * @param accessKey - Optional access key for private networks
+     * @param createView - Whether to create a network view (default: undefined)
+     * @returns Promise resolving to import result
+     */
+    postNDExNetworkToCytoscape(uuid: string, accessKey?: string, createView?: boolean): Promise<any>;
+    /**
+     * Import CX network data to Cytoscape
+     *
+     * @param cx - CX format network data
+     * @returns Promise resolving to import result
+     */
+    postCXNetworkToCytoscape(cx: any): Promise<any>;
+    /**
+     * Import CX2 network data to Cytoscape
+     *
+     * @param cx2_string - CX2 format network data as string
+     * @param title - Network title
+     * @param collection_name - Collection name
+     * @returns Promise resolving to import result
+     */
+    postCX2NetworkToCytoscape(cx2_string: string, title: string, collection_name: string): Promise<any>;
+    /**
+     * Export network from Cytoscape to NDEx (create new network)
+     *
+     * @param suid - Network SUID or 'current' for current network (default: 'current')
+     * @returns Promise resolving to export result
+     */
+    postCytoscapeNetworkToNDEx(suid?: string): Promise<any>;
+    /**
+     * Update existing network in NDEx with data from Cytoscape
+     *
+     * @param suid - Network SUID or 'current' for current network (default: 'current')
+     * @param uuid - Target NDEx network UUID to update
+     * @returns Promise resolving to update result
+     */
+    putCytoscapeNetworkInNDEx(suid: string, uuid: string): Promise<any>;
+}
+
+/**
+ * NDExClient - Main client class for NDEx API operations
+ *
+ * Provides a unified interface for all NDEx operations with intelligent
+ * version routing between v2 and v3 APIs.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const client = new NDExClient({
+ *   baseURL: 'https://www.ndexbio.org',
+ *   debug: true
+ * });
+ *
+ * // Authenticate
+ * await client.user.authenticate({ username: 'user', password: 'pass' });
+ *
+ * // Search networks
+ * const results = await client.networks.searchNetworks({ searchString: 'pathway' });
+ *
+ * // Get network as CX2
+ * const network = await client.networks.getNetworkAsCX2Object('network-uuid');
+ *
+ * // User operations
+ * const profile = await client.user.getCurrentUser();
+ *
+ * // Admin operations (requires admin privileges)
+ * const stats = await client.admin.getSystemStats();
+ * ```
+ */
+declare class NDExClient {
+    private httpService;
+    /** Network operations with intelligent v2/v3 routing */
+    readonly networks: UnifiedNetworkService;
+    /** File upload/download and task management */
+    readonly files: FilesService;
+    /** Workspace operations (deprecated - most functionality moved to other services) */
+    readonly workspace: WorkspaceService;
+    /** User authentication and management */
+    readonly user: UserService;
+    /** System administration operations */
+    readonly admin: AdminService;
+    constructor(config?: NDExClientConfig);
+    /**
+     * Clear authentication
+     */
+    logout(): void;
+    /**
+     * Get server status information
+     * Can be called by authenticated or anonymous users.
+     * @param format - Optional format parameter. Use 'full' for detailed information including properties and importers/exporters
+     * @returns Server status including network/user counts and optional server details
+     */
+    getServerStatus(format?: 'full'): Promise<{
+        message: string;
+        properties?: {
+            ServerVersion: string;
+            Build: string;
+            ServerResultLimit: string;
+            ImporterExporters: Array<{
+                importer: boolean;
+                exporter: boolean;
+                fileExtension: string;
+                name: string;
+                description: string;
+            }>;
+        };
+        networkCount: number;
+        userCount: number;
+        groupCount?: number;
+    }>;
+    /**
+     * Check if client has valid authentication information configured
+     * @returns true if auth is a valid BasicAuth or OAuthAuth object, false otherwise
+     */
+    hasAuthInfo(): boolean;
+    /**
+     * Update client configuration
+     */
+    updateConfig(config: Partial<NDExClientConfig>): void;
+    /**
+     * Get current client configuration
+     */
+    getConfig(): NDExClientConfig;
+    /**
+     * Access to low-level HTTP service for advanced usage
+     */
+    get http(): HTTPService;
+    /**
+     * Access to version-specific network services for advanced usage
+     */
+    get v2(): {
+        networks: NetworkServiceV2;
+    };
+    get v3(): {
+        networks: NetworkServiceV3;
+    };
+}
+declare const version: string;
+
+export { type APIError, type APIResponse, type AccessKeyAction, type AccessKeyResponse, type AccessParams, AdminService, type BasicAuth, type CX1Edge, type CX1MetaDataItem, type CX1MetaDataResponse, type CX1NetworkProperty, type CX2AttributeDeclarations, type CX2AttributeSpec, type CX2Edge, type CX2EdgeBypass, type CX2ImportParams, type CX2MetaData, CX2Network, type CX2NetworkAttribute, type CX2NetworkProperties, type CX2Node, type CX2NodeBypass, type CX2Status, type CX2VisualProperty, CyNDExService as CyNDEx, type CyNDExAuthConfig, type CyNDExConfig, CyNDExService, type CyNDExStatusResponse, type CyWebWorkspace, type CytoscapeNetworkSummary, type DefaultVisualProperties, type ExportFormat, type ExportRequest, FilesService, HTTPService, type MappingDefinition, type NDExAny, NDExAuthError, type NDExAuthResponse, NDExClient, type NDExClientConfig, NDExError, type NDExExportParams, type NDExImportParams, NDExNetworkError, NDExNotFoundError, NDExServerError, type NDExUser, NDExValidationError, NetworkIndexLevel, type NetworkPermission, NetworkServiceV2, NetworkServiceV3, type NetworkSummaryV2, type NetworkSummaryV3, type OAuthAuth, type PaginationParams, type SearchParameters, type SearchResult, type TableColumnVisualStyle, type Task, type Timestamp, type UUID, UnifiedNetworkService, UserService, type VPMappingType, type VisualPropertyMapping, type VisualPropertyTable, WorkspaceService, version };