@js4cytoscape/ndex-client 0.6.0-alpha.1 → 0.6.0-alpha.3

package/dist/index.d.ts

@@ -1,8 +1,134 @@
 import { AxiosRequestConfig } from 'axios';
 
+/**
+ * NDEx Client Constants
+ *
+ * Centralized definition of all string literal constants used throughout the NDEx client library.
+ * Using the const + type pattern for better developer experience with autocomplete and type safety.
+ */
+/**
+ * Authentication types supported by NDEx client
+ */
+declare const AuthType: {
+    readonly BASIC: "basic";
+    readonly OAUTH: "oauth";
+};
+declare type AuthType = (typeof AuthType)[keyof typeof AuthType];
+/**
+ * Visibility settings for networks, folders, and shortcuts.
+ * Based on YouTube's permission model.
+ *
+ * ## Visibility Type Definitions:
+ *
+ * **PUBLIC**
+ * - Accessibility: Anyone can discover and view the content
+ * - Searchability: Appears in search results and can be found through search engines
+ * - Sharing: Can be shared freely with anyone
+ * - Visibility: Shows up on the owner's public profile
+ *
+ * **PRIVATE**
+ * - Accessibility: Only the owner and specifically invited users can view the content
+ * - Searchability: Does not appear in any search results (internal or external)
+ * - Sharing: Even with a direct link, uninvited users cannot access the content
+ * - Visibility: Does not appear on the owner's public profile
+ *
+ * **UNLISTED**
+ * - Accessibility: Anyone with the direct link can view the content
+ * - Searchability: Does not appear in search results unless added to a public collection
+ * - Sharing: Can be shared via direct link without requiring special permissions
+ * - Visibility: Does not appear on the owner's public profile
+ *
+ * @example
+ * ```typescript
+ * const network: NetworkSummaryV3 = {
+ *   externalId: "12345",
+ *   name: "Sample Network",
+ *   visibility: Visibility.UNLISTED // Only accessible via direct link
+ * };
+ * ```
+ */
+declare const Visibility: {
+    readonly PUBLIC: "PUBLIC";
+    readonly PRIVATE: "PRIVATE";
+    readonly UNLISTED: "UNLISTED";
+};
+declare type Visibility = (typeof Visibility)[keyof typeof Visibility];
+/**
+ * Permission levels for network and folder access control.
+ *
+ * ## Permission Level Definitions:
+ *
+ * **READ**
+ * - View the network/folder content
+ * - Download network data
+ * - Access network metadata and summary information
+ *
+ * **WRITE**
+ * - All READ permissions
+ * - Modify network content and metadata
+ * - Update network properties and attributes
+ *
+ * **ADMIN**
+ * - All WRITE permissions
+ * - Delete networks/folders
+ * - Manage permissions for other users
+ * - Transfer ownership
+ *
+ * @example
+ * ```typescript
+ * const permission: NetworkPermission = {
+ *   uuid: "permission-uuid",
+ *   permission: Permission.WRITE,
+ *   memberUUID: "user-uuid",
+ *   resourceUUID: "network-uuid"
+ * };
+ * ```
+ */
+declare const Permission: {
+    readonly READ: "READ";
+    readonly WRITE: "WRITE";
+    readonly ADMIN: "ADMIN";
+};
+declare type Permission = (typeof Permission)[keyof typeof Permission];
+/**
+ * File types for NDEx objects
+ */
+declare const NDExFileType: {
+    readonly NETWORK: "NETWORK";
+    readonly FOLDER: "FOLDER";
+    readonly SHORTCUT: "SHORTCUT";
+};
+declare type NDExFileType = (typeof NDExFileType)[keyof typeof NDExFileType];
+/**
+ * Visual Property Mapping Types for CX2 networks
+ */
+declare const VPMappingType: {
+    readonly DISCRETE: "DISCRETE";
+    readonly CONTINUOUS: "CONTINUOUS";
+    readonly PASSTHROUGH: "PASSTHROUGH";
+};
+declare type VPMappingType = (typeof VPMappingType)[keyof typeof VPMappingType];
+/**
+ * CX data types for network properties and attributes
+ */
+declare const CXDataType: {
+    readonly STRING: "string";
+    readonly LONG: "long";
+    readonly INTEGER: "integer";
+    readonly DOUBLE: "double";
+    readonly BOOLEAN: "boolean";
+    readonly LIST_OF_STRING: "list_of_string";
+    readonly LIST_OF_LONG: "list_of_long";
+    readonly LIST_OF_INTEGER: "list_of_integer";
+    readonly LIST_OF_DOUBLE: "list_of_double";
+    readonly LIST_OF_BOOLEAN: "list_of_boolean";
+};
+declare type CXDataType = (typeof CXDataType)[keyof typeof CXDataType];
+
 /**
  * Type definitions for CyNDEx (Cytoscape-NDEx Bridge) operations
  */
+
 /**
  * Configuration for CyNDEx service
  */
@@ -19,7 +145,7 @@ interface CyNDExConfig {
  * This is used as parameters passed to Cytoscape for NDEx authentication
  */
 interface CyNDExAuthConfig {
-    type: 'basic' | 'oauth';
+    type: AuthType;
     username?: string;
     password?: string;
     idToken?: string;
@@ -75,18 +201,612 @@ interface CX2ImportParams {
     title?: string;
 }
 
+/**
+ * Permission details for a file including its type and member permissions
+ *
+ * @description This interface represents the permission information for a single file,
+ * including what type of file it is and which users have what permissions on it.
+ */
+interface FilePermissionDetails {
+    /**
+     * The type of the file (NETWORK, FOLDER, or SHORTCUT)
+     */
+    type: NDExFileType;
+    /**
+     * Map of user UUIDs to their permission levels on this file
+     *
+     * @description Each key represents a user's UUID, and the corresponding value
+     * indicates what permission level that user has on the file.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   "user1-uuid-1234-5678-9abc-def012345678": "READ",
+     *   "user2-uuid-8765-4321-fedc-ba0987654321": "WRITE",
+     *   "user3-uuid-1111-2222-3333-444444444444": "ADMIN"
+     * }
+     * ```
+     */
+    members: Record<string, Permission>;
+}
+/**
+ * List of file permission records returned by listMembers
+ *
+ * @description Each element in the array is a record where the key is a file UUID
+ * and the value contains the file's type and member permissions.
+ *
+ * @example
+ * ```typescript
+ * [
+ *   {
+ *     "12345678-1234-1234-1234-123456789abc": {
+ *       type: "NETWORK",
+ *       members: {
+ *         "user1-uuid": "READ",
+ *         "user2-uuid": "WRITE"
+ *       }
+ *     }
+ *   },
+ *   {
+ *     "87654321-4321-4321-4321-876543210fed": {
+ *       type: "FOLDER",
+ *       members: {
+ *         "user3-uuid": "ADMIN"
+ *       }
+ *     }
+ *   }
+ * ]
+ * ```
+ */
+declare type FilePermissionList = Record<string, FilePermissionDetails>[];
+/**
+ * Request object for sharing member operations
+ *
+ * This interface defines the structure for requests that manage file sharing permissions.
+ * It combines file identification with member permission management in a single request.
+ */
+interface SharingMemberRequest {
+    /**
+     * Object mapping file UUIDs to their corresponding file types
+     *
+     * @description Each key represents the UUID of a file to be shared, and the value
+     * indicates what type of file it is (NETWORK, FOLDER, or SHORTCUT)
+     *
+     * @example
+     * ```typescript
+     * {
+     *   "12345678-1234-1234-1234-123456789abc": "NETWORK",
+     *   "87654321-4321-4321-4321-876543210fed": "FOLDER"
+     * }
+     * ```
+     */
+    files: Record<string, NDExFileType>;
+    /**
+     * Object mapping member UUIDs to their permission levels
+     *
+     * @description Each key represents the UUID of a user or member who should receive
+     * explicit permissions, and the value is the type of permission they should have.
+     * If the permission value is null, the existing file permission for the member will be revoked.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   "user1-uuid-1234-5678-9abc-def012345678": "READ",
+     *   "user2-uuid-8765-4321-fedc-ba0987654321": "WRITE",
+     *   "user3-uuid-1111-2222-3333-444444444444": null // This will revoke permissions
+     * }
+     * ```
+     */
+    members: Record<string, Permission | null>;
+}
+/**
+ * Parameters for searching files in NDEx
+ */
+interface FileSearchParams {
+    /** Search terms as a string, supports Lucene syntax */
+    searchString?: string;
+    /** Username of the account to filter on, only files owned by that user will be returned */
+    accountName?: string;
+    /** Filter by permission level, only applicable to signed-in users */
+    permission?: Permission;
+    /** File type to filter on, if null or omitted all file types will be returned */
+    type?: NDExFileType | null;
+    /** Visibility filter, only supports "PRIVATE" or "PUBLIC" */
+    visibility: 'PRIVATE' | 'PUBLIC';
+    /** Starting index for pagination */
+    start?: number;
+    /** Number of results to return for pagination */
+    size?: number;
+}
+interface CreateShortcutOptions {
+    name: string;
+    target: string;
+    targetType: NDExFileType;
+    parent?: string;
+}
+/**
+ * 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
+     *
+     * Copies a network or shortcut to a target folder. Folder copying is not supported.
+     * The copied file will be placed in the specified target folder with the same name
+     * and properties as the original.
+     *
+     * @param options - Copy operation configuration
+     * @param options.fileId - UUID of the source file to copy
+     * @param options.targetId - UUID of the target folder where the file will be copied
+     * @param options.type - Type of file being copied (only NETWORK and SHORTCUT are supported)
+     * @param options.accessKey - Optional access key for accessing protected files
+     * @returns Promise resolving to the copied file's UUID and modification time
+     *
+     * @example
+     * ```typescript
+     * // Copy a network to a specific folder
+     * await client.files.copyFile({
+     *   fileId: "12345678-1234-1234-1234-123456789abc",
+     *   targetId: "87654321-4321-4321-4321-876543210fed",
+     *   type: "NETWORK"
+     * });
+     *
+     * // Copy a shortcut with access key
+     * await client.files.copyFile({
+     *   fileId: "11111111-2222-3333-4444-555555555555",
+     *   targetId: "66666666-7777-8888-9999-000000000000",
+     *   type: "SHORTCUT",
+     *   accessKey: "secret-key-123"
+     * });
+     * ```
+     */
+    copyFile(options: {
+        fileId: string;
+        targetId: string;
+        type: NDExFileType;
+        accessKey?: string;
+    }): Promise<NDExObjectUpdateStatus>;
+    /** 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;
+    /**
+     * Update member permissions for shared files
+     *
+     * This method allows you to grant, modify, or revoke permissions for specific members
+     * across multiple files in a single operation. It's particularly useful for bulk
+     * permission management and ensuring consistent access control.
+     *
+     * @param request - The sharing member request containing files and member permissions
+     * @param request.files - Object mapping file UUIDs to their file types
+     * @param request.members - Object mapping member UUIDs to their permission levels (or null to revoke)
+     *
+     * @returns Promise resolving to an object with file UUIDs as keys and permission status messages as values
+     *
+     * @example
+     * ```typescript
+     * // Grant permissions to multiple members for different files
+     * const result = await client.files.updateMember({
+     *   files: {
+     *     "network-uuid-123": "NETWORK",
+     *     "folder-uuid-456": "FOLDER"
+     *   },
+     *   members: {
+     *     "user1-uuid": "READ",
+     *     "user2-uuid": "WRITE",
+     *     "user3-uuid": null // Revoke permissions
+     *   }
+     * });
+     *
+     * // Result example:
+     * // {
+     * //   "network-uuid-123": "network permission granted",
+     * //   "folder-uuid-456": "folder permission granted"
+     * // }
+     *
+     * // Revoke all permissions for a user
+     * await client.files.updateMember({
+     *   files: {
+     *     "network-uuid-789": "NETWORK"
+     *   },
+     *   members: {
+     *     "user-to-remove-uuid": null
+     *   }
+     * });
+     * ```
+     *
+     * @throws {Error} When file UUIDs have invalid format
+     * @throws {Error} When file types are invalid
+     * @throws {Error} When member UUIDs have invalid format
+     */
+    updateMember(request: SharingMemberRequest): Promise<Record<string, string>>;
+    /**
+     * List members and their permissions for specified files
+     *
+     * Retrieves detailed permission information for the specified files, including
+     * the file type and a mapping of all users who have explicit permissions on each file.
+     * This is useful for auditing file access and understanding who has what level of
+     * access to your shared content.
+     *
+     * @param files - Object mapping file UUIDs to their file types
+     * @returns Promise resolving to a list of permission records for each file
+     *
+     * @example
+     * ```typescript
+     * // Get permission details for multiple files
+     * const permissions = await client.files.listMembers({
+     *   "12345678-1234-1234-1234-123456789abc": "NETWORK",
+     *   "87654321-4321-4321-4321-876543210fed": "FOLDER",
+     *   "11111111-2222-3333-4444-555555555555": "SHORTCUT"
+     * });
+     *
+     * // Result example:
+     * // [
+     * //   {
+     * //     "12345678-1234-1234-1234-123456789abc": {
+     * //       type: "NETWORK",
+     * //       members: {
+     * //         "user1-uuid-1234-5678-9abc-def012345678": "READ",
+     * //         "user2-uuid-8765-4321-fedc-ba0987654321": "WRITE",
+     * //         "user3-uuid-1111-2222-3333-444444444444": "ADMIN"
+     * //       }
+     * //     }
+     * //   },
+     * //   {
+     * //     "87654321-4321-4321-4321-876543210fed": {
+     * //       type: "FOLDER",
+     * //       members: {
+     * //         "user4-uuid-aaaa-bbbb-cccc-dddddddddddd": "ADMIN",
+     * //         "user5-uuid-eeee-ffff-0000-111111111111": "READ"
+     * //       }
+     * //     }
+     * //   }
+     * // ]
+     *
+     * // Access specific file permissions
+     * const networkPermissions = permissions.find(record =>
+     *   record["12345678-1234-1234-1234-123456789abc"]
+     * )?.["12345678-1234-1234-1234-123456789abc"];
+     *
+     * if (networkPermissions) {
+     *   console.log('File type:', networkPermissions.type); // "NETWORK"
+     *   console.log('Members:', networkPermissions.members);
+     *
+     *   // Check if specific user has permission
+     *   const userPermission = networkPermissions.members["user1-uuid-1234-5678-9abc-def012345678"];
+     *   console.log('User permission:', userPermission); // "READ"
+     * }
+     * ```
+     *
+     * @throws {Error} When file UUIDs have invalid format
+     * @throws {Error} When file types are invalid
+     */
+    listMembers(files: Record<string, NDExFileType>): Promise<FilePermissionList>;
+    /**
+     * Transfer ownership of networks to a new owner
+     *
+     * This method transfers ownership of multiple networks to a specified user.
+     * The current owner will lose ownership rights, and the new owner will gain
+     * full control over the specified networks.
+     *
+     * @param request - Transfer ownership request
+     * @param request.networks - Array of network UUIDs to transfer ownership for
+     * @param request.newOwner - UUID of the user who will become the new owner
+     * @returns Promise that resolves when the ownership transfer is complete
+     *
+     * @example
+     * ```typescript
+     * // Transfer ownership of multiple networks to a new owner
+     * await client.files.transferOwnership({
+     *   networks: [
+     *     "12345678-1234-1234-1234-123456789abc",
+     *     "87654321-4321-4321-4321-876543210fed"
+     *   ],
+     *   newOwner: "new-owner-uuid-1111-2222-3333-444444444444"
+     * });
+     * ```
+     */
+    transferOwnership(request: {
+        networks: string[];
+        newOwner: string;
+    }): Promise<void>;
+    listShares(limit?: number): Promise<FileListItem[]>;
+    /**
+     * Share files with public access
+     *
+     * Makes specified files publicly accessible by generating access keys for each file.
+     * The generated access keys can be used by others to access the shared files without
+     * requiring explicit permissions.
+     *
+     * @param fileTable - Object mapping file UUIDs to their file types
+     * @returns Promise resolving to an object mapping file UUIDs to their generated access keys
+     *
+     * @example
+     * ```typescript
+     * // Share a network and a folder
+     * const result = await client.files.share({
+     *   "e6fc6a72-59ea-4f1d-ad81-59eda2cb8dce": "NETWORK",
+     *   "40c08b7b-a4dd-4f00-87b3-1b945991948a": "FOLDER"
+     * });
+     *
+     * // Result example:
+     * // {
+     * //   "e6fc6a72-59ea-4f1d-ad81-59eda2cb8dce": "abc123def456",
+     * //   "40c08b7b-a4dd-4f00-87b3-1b945991948a": "xyz789uvw012"
+     * // }
+     *
+     * // Use the access key to access shared content
+     * const sharedNetwork = await client.networks.getNetwork(
+     *   "e6fc6a72-59ea-4f1d-ad81-59eda2cb8dce",
+     *   { accessKey: result["e6fc6a72-59ea-4f1d-ad81-59eda2cb8dce"] }
+     * );
+     * ```
+     */
+    share(fileTable: Record<string, NDExFileType>): Promise<Record<string, string>>;
+    unshare(fileTable: Record<string, NDExFileType>): Promise<void>;
+    getFolders(limit?: number): Promise<any>;
+    createFolder(name: string, parentFolderId?: string): Promise<any>;
+    getFolder(folderId: string, accessKey?: string): Promise<any>;
+    /**
+     * Update folder properties
+     *
+     * Updates the properties of an existing folder including name, description, and parent location.
+     * When parent is omitted, the folder remains in or is moved to the owner's home directory.
+     *
+     * @param folderId - The UUID of the folder to update
+     * @param folderData - Object containing folder properties to update
+     * @param folderData.name - The new name for the folder
+     * @param folderData.description - The new description for the folder
+     * @param folderData.parent - Optional UUID of the parent folder. If omitted, folder is placed in owner's home directory
+     * @returns Promise that resolves when the folder update is complete
+     *
+     * @example
+     * ```typescript
+     * // Update folder name and description, keep in current location
+     * await client.files.updateFolder('folder-uuid', {
+     *   name: 'Updated Folder Name',
+     *   description: 'Updated folder description'
+     * });
+     *
+     * // Move folder to a different parent and update properties
+     * await client.files.updateFolder('folder-uuid', {
+     *   name: 'Moved Folder',
+     *   description: 'This folder has been moved',
+     *   parent: 'parent-folder-uuid'
+     * });
+     *
+     * // Move folder to home directory by omitting parent
+     * await client.files.updateFolder('folder-uuid', {
+     *   name: 'Home Folder',
+     *   description: 'Moved to home directory'
+     * });
+     * ```
+     */
+    updateFolder(folderId: string, folderData: {
+        name: string;
+        description: string;
+        parent?: string;
+    }): Promise<void>;
+    deleteFolder(folderId: string): Promise<any>;
+    getFolderCount(folderId: string, accessKey?: string): Promise<any>;
+    getFolderList(folderId: string, accessKey?: string, format?: string, type?: string): Promise<FileListItem[]>;
+    /**
+     * Get folder access key
+     *
+     * Retrieves the access key for a folder if it has been enabled for public access.
+     * When a folder has an access key enabled, it can be accessed by others without
+     * explicit permissions using this key.
+     *
+     * @param folderId - The UUID of the folder to get the access key for
+     * @returns Promise resolving to an object with accessKey property when enabled,
+     *          or null when access key is not enabled on this folder
+     *
+     * @example
+     * ```typescript
+     * // Check if folder has an access key
+     * const result = await client.files.getFolderAccessKey('12345678-1234-1234-1234-123456789abc');
+     *
+     * if (result) {
+     *   console.log('Access key:', result.accessKey); // "sdfdfdfsdfdsfs"
+     *   // Use the access key to access the folder
+     *   const folderData = await client.files.getFolder(folderId, result.accessKey);
+     * } else {
+     *   console.log('No access key enabled for this folder');
+     * }
+     * ```
+     */
+    getFolderAccessKey(folderId: string): Promise<{
+        accessKey: string;
+    } | null>;
+    getShortcuts(limit?: number): Promise<any>;
+    /**
+     * Create a shortcut to an existing NDEx object
+     *
+     * Creates a shortcut (reference) to an existing network, folder, or shortcut.
+     * The shortcut can be placed in a specific folder or in the user's home directory.
+     *
+     * @param options - Shortcut creation options
+     * @param options.name - Display name for the shortcut
+     * @param options.target - UUID of the target object to create a shortcut to
+     * @param options.targetType - Type of the target object ('NETWORK', 'FOLDER', or 'SHORTCUT')
+     * @param options.parent - Optional UUID of the parent folder. If omitted, shortcut is created in user's home directory
+     * @returns Promise resolving to the created shortcut information
+     *
+     * @example
+     * ```typescript
+     * // Create shortcut to a network in home directory
+     * await client.files.createShortcut({
+     *   name: "My Important Network Shortcut",
+     *   target: "12345678-1234-1234-1234-123456789abc",
+     *   targetType: "NETWORK"
+     * });
+     *
+     * // Create shortcut to a folder within another folder
+     * await client.files.createShortcut({
+     *   name: "Research Folder Shortcut",
+     *   target: "87654321-4321-4321-4321-876543210fed",
+     *   targetType: "FOLDER",
+     *   parent: "11111111-2222-3333-4444-555555555555"
+     * });
+     * ```
+     */
+    createShortcut(options: CreateShortcutOptions): Promise<NDExObjectUpdateStatus>;
+    getShortcut(shortcutId: string, accessKey?: string): Promise<Shortcut>;
+    /**
+     * Update shortcut properties
+     *
+     * Updates the properties of an existing shortcut including name, parent location, target, and target type.
+     * The parent attribute is always included in the request payload - when parent is omitted from the shortcut object,
+     * parent is set to null to indicate the shortcut should be moved to the owner's home directory.
+     *
+     * @param shortcutId - The UUID of the shortcut to update
+     * @param shortcutObject - Object containing shortcut properties to update
+     * @param shortcutObject.name - The new name for the shortcut
+     * @param shortcutObject.target - UUID of the target object the shortcut points to
+     * @param shortcutObject.targetType - Type of the target object ('NETWORK', 'FOLDER', or 'SHORTCUT')
+     * @param shortcutObject.parent - Optional UUID of the parent folder. If omitted, shortcut is moved to home directory
+     * @returns Promise resolving when the shortcut update is complete
+     *
+     * @example
+     * ```typescript
+     * // Update shortcut name and target, move to home directory
+     * await client.files.updateShortcut('shortcut-uuid', {
+     *   name: 'Updated Shortcut Name',
+     *   target: 'target-network-uuid',
+     *   targetType: 'NETWORK'
+     * });
+     *
+     * // Update shortcut and move to a specific folder
+     * await client.files.updateShortcut('shortcut-uuid', {
+     *   name: 'Folder Shortcut',
+     *   target: 'target-folder-uuid',
+     *   targetType: 'FOLDER',
+     *   parent: 'parent-folder-uuid'
+     * });
+     *
+     * // Update all shortcut properties
+     * await client.files.updateShortcut('shortcut-uuid', {
+     *   name: 'Complete Update',
+     *   target: 'target-network-uuid',
+     *   targetType: 'NETWORK',
+     *   parent: 'parent-folder-uuid'
+     * });
+     * ```
+     */
+    updateShortcut(shortcutId: string, shortcutObject: CreateShortcutOptions): Promise<any>;
+    deleteShortcut(shortcutId: string): Promise<any>;
+    /**
+     * Set visibility for multiple files
+     *
+     * Updates the visibility settings for the specified files, controlling who can
+     * access them based on the visibility level (public, private, etc.).
+     *
+     * @param options - Visibility update configuration
+     * @param options.files - Object mapping file UUIDs to their file types
+     * @param options.visibility - The visibility level to apply to all specified files
+     * @returns Promise that resolves when the visibility has been updated
+     *
+     * @example
+     * ```typescript
+     * // Make multiple files public
+     * await client.files.setVisibility({
+     *   files: {
+     *     "12345678-1234-1234-1234-123456789abc": "NETWORK",
+     *     "87654321-4321-4321-4321-876543210fed": "FOLDER"
+     *   },
+     *   visibility: "PUBLIC"
+     * });
+     * ```
+     */
+    setVisibility(options: {
+        files: Record<string, NDExFileType>;
+        visibility: Visibility;
+    }): Promise<void>;
+    /**
+     * Search for files in NDEx
+     *
+     * Searches for networks, folders, and shortcuts based on various criteria including
+     * search terms, ownership, permissions, file type, and visibility. Results are paginated
+     * and support Lucene query syntax for advanced search capabilities.
+     *
+     * @param params - Search parameters
+     * @param params.searchString - Search terms as a string, supports Lucene syntax
+     * @param params.accountName - Username to filter files by owner
+     * @param params.permission - Filter by permission level (only for signed-in users)
+     * @param params.type - File type filter (NETWORK, FOLDER, SHORTCUT, or null for all types)
+     * @param params.visibility - Visibility filter (required, "PRIVATE" or "PUBLIC")
+     * @param params.start - Starting index for pagination (default: 0)
+     * @param params.size - Number of results to return (default: varies by server)
+     * @returns Promise resolving to search results containing matching files
+     *
+     * @example
+     * ```typescript
+     * // Search for public networks containing "cancer"
+     * const results = await client.files.searchFiles({
+     *   searchString: "cancer",
+     *   type: "NETWORK",
+     *   visibility: "PUBLIC",
+     *   start: 0,
+     *   size: 25
+     * });
+     *
+     * console.log(`Found ${results.numFound} total results`);
+     * console.log(`Showing results starting at ${results.start}`);
+     * results.ResultList.forEach(file => {
+     *   console.log(`${file.name} (${file.type})`);
+     * });
+     *
+     * // Search with Lucene syntax for networks owned by specific user
+     * const userNetworks = await client.files.searchFiles({
+     *   searchString: "name:pathway AND description:signaling",
+     *   accountName: "john_doe",
+     *   type: "NETWORK",
+     *   visibility: "PUBLIC"
+     * });
+     *
+     * // Search for all private files the signed-in user has WRITE permission on
+     * const writableFiles = await client.files.searchFiles({
+     *   permission: "WRITE",
+     *   visibility: "PRIVATE",
+     *   start: 0,
+     *   size: 50
+     * });
+     * ```
+     */
+    searchFiles(params: FileSearchParams): Promise<SearchResult<FileListItem>>;
+}
+
 /**
  * Core type definitions for NDEx Client Library
  * Pragmatic TypeScript types allowing flexibility with any types where needed
  */
 
 interface BasicAuth {
-    type: 'basic';
+    type: typeof AuthType.BASIC;
     username: string;
     password: string;
 }
 interface OAuthAuth {
-    type: 'oauth';
+    type: typeof AuthType.OAUTH;
     idToken: string;
 }
 interface NDExAuthResponse {
@@ -124,14 +844,89 @@ interface CX1MetaDataResponse {
 interface CX1NetworkProperty {
     predicateString: string;
     value: string;
-    dataType?: 'string' | 'integer' | 'double' | 'boolean' | 'list_of_string';
+    dataType?: CXDataType;
 }
+/**
+ * CX2 network properties structure
+ *
+ * @description Represents network properties in CX2 format, where each property
+ * is defined with both its data type and value. This format allows for type-safe
+ * property handling and is the standard way properties are stored in CX2 networks.
+ *
+ * The key represents the name of the attribute, and the value contains both the
+ * data type specification and the actual value.
+ *
+ * @example
+ * ```typescript
+ * const networkProps: CX2NetworkProperties = {
+ *   name: {
+ *     t: "string",
+ *     v: "My Network"
+ *   },
+ *   nodeCount: {
+ *     t: "integer",
+ *     v: 150
+ *   },
+ *   version: {
+ *     t: "double",
+ *     v: 1.5
+ *   },
+ *   tags: {
+ *     t: "list_of_string",
+ *     v: ["biology", "protein-interaction", "human"]
+ *   },
+ *   isPublic: {
+ *     t: "boolean",
+ *     v: true
+ *   }
+ * };
+ *
+ * // Applications can use the value directly
+ * const networkName = networkProps.name.v; // "My Network"
+ * const nodeCount = networkProps.nodeCount.v; // 150
+ * ```
+ */
 interface CX2NetworkProperties {
+    /**
+     * Property definition indexed by attribute name
+     *
+     * @description Each key represents the name of a network attribute, and the
+     * corresponding value contains the type specification and actual value.
+     */
     [key: string]: {
-        t: string;
+        /**
+         * Data type of the attribute
+         *
+         * @description Specifies the CX2 data type for this attribute. Common types include:
+         * - `"string"` - Text values
+         * - `"long"` - Long integer values
+         * - `"integer"` - Whole numbers
+         * - `"double"` - Decimal numbers
+         * - `"boolean"` - True/false values
+         * - `"list_of_string"` - Array of text values
+         * - `"list_of_long"` - Array of long integers
+         * - `"list_of_integer"` - Array of whole numbers
+         * - `"list_of_double"` - Array of decimal numbers
+         * - `"list_of_boolean"` - Array of boolean values
+         *
+         * @example CXDataType.STRING, CXDataType.INTEGER, CXDataType.DOUBLE, CXDataType.LIST_OF_STRING
+         */
+        t: CXDataType;
+        /**
+         * Actual value of the attribute
+         *
+         * @description The concrete value for this attribute. Applications can
+         * typically use this value directly without additional processing. The
+         * type of this value should correspond to the data type specified in `t`.
+         *
+         * @example "My Network", 150, 1.5, true, ["tag1", "tag2"]
+         */
         v: any;
     };
 }
+/**
+ * @deprecated Since NDEx version 3.0, all networks/folders and shortcuts are indexed in the system by default.
+ */
 declare enum NetworkIndexLevel {
     NONE = "NONE",
     BASIC = "BASIC",
@@ -143,7 +938,7 @@ interface NetworkSummaryV2 {
     description?: string;
     nodeCount: number;
     edgeCount: number;
-    visibility: 'PUBLIC' | 'PRIVATE';
+    visibility: Visibility;
     owner: string;
     ownerUUID: string;
     creationTime: number;
@@ -217,7 +1012,7 @@ interface NetworkSummaryV3 extends Omit<NetworkSummaryV2, 'properties'> {
 }
 interface NetworkPermission {
     uuid: string;
-    permission: 'READ' | 'WRITE' | 'ADMIN';
+    permission: Permission;
     memberUUID: string;
     memberAccountName?: string;
     resourceUUID: string;
@@ -280,10 +1075,6 @@ 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
@@ -334,10 +1125,10 @@ interface CX2Status {
     error?: string;
     success?: boolean;
 }
-interface SearchResult {
-    numFound: number;
+interface SearchResult<T> {
+    ResultList: T[];
     start: number;
-    networks: NetworkSummaryV2[] | NetworkSummaryV3[];
+    numFound: number;
 }
 interface SearchParameters {
     searchString?: string;
@@ -397,17 +1188,17 @@ interface APIError {
  * 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);
+    statusCode?: number | undefined;
+    errorCode?: string | undefined;
+    description?: string | undefined;
+    constructor(message: string, statusCode?: number | undefined, errorCode?: string | undefined, description?: string | undefined);
 }
 /**
  * Error thrown when network or request fails
  */
 declare class NDExNetworkError extends NDExError {
-    originalError?: Error;
-    constructor(message: string, originalError?: Error);
+    originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
 }
 /**
  * Error thrown when authentication fails
@@ -463,6 +1254,63 @@ interface AccessKeyResponse {
  * Valid actions for updating access keys
  */
 declare type AccessKeyAction = 'enable' | 'disable';
+/**
+ * NDEx object update status - returned from network creation and update operations
+ * Corresponds to server-side NdexObjectUpdateStatus class
+ */
+interface NDExObjectUpdateStatus {
+    uuid: string;
+    modificationTime: number;
+}
+/**
+ * Items in a file list returned for a folder or user account
+ *
+ * @property uuid - Unique identifier of the file
+ * @property type - Type of the file (folder, network, or shortcut)
+ * @property name - Name of the file (optional for some items)
+ * @property modificationTime - Last modification timestamp
+ * @property updatedBy - Username of the user who last updated the file (optional)
+ * @property attributes - Additional attributes associated with the file
+ * @property isShared - Whether the file is shared (optional)
+ * @property isReadOnly - Whether the file is read-only (networks only, optional)
+ * @property warnings - Array of warning messages (networks only, optional)
+ * @property isCompleted - Whether the file processing is completed (networks only, optional)
+ * @property errorMessage - Error message if file has errors (optional)
+ */
+interface FileListItem {
+    uuid: string;
+    name?: string;
+    type: NDExFileType;
+    modificationTime: number;
+    attributes: any;
+    updatedBy?: string;
+    owner?: string;
+    ownerUUID?: string;
+    visibility?: Visibility;
+    edges?: number;
+    permission?: Permission;
+    isReadOnly?: boolean;
+    isShared?: boolean;
+    warnings?: string[];
+    isCompleted?: boolean;
+    errorMessage?: string;
+    isValid?: boolean;
+    DOI: string;
+}
+/**
+ * Shortcut object structure returned from shortcut operations
+ *
+ * @property name - Name of the shortcut
+ * @property parent - UUID of the parent folder (optional)
+ * @property target - UUID of the target object
+ * @property targetType - File type of the target object
+ */
+interface Shortcut {
+    name: string;
+    parent?: string;
+    target: string;
+    targetType: NDExFileType;
+}
 
 /**
  * HTTPService - Core HTTP client for NDEx API communication
@@ -470,6 +1318,7 @@ declare type AccessKeyAction = 'enable' | 'disable';
  *
  * @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.
+ * @internal
  */
 declare class HTTPService {
     private axiosInstance;
@@ -507,67 +1356,7 @@ declare class HTTPService {
     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';
@@ -598,9 +1387,9 @@ declare class HTTPService {
     getConfig(): NDExClientConfig;
     /**
      * Get current authentication type
-     * @returns The type of authentication configured ('basic' | 'oauth'), or undefined if no auth is configured
+     * @returns The type of authentication configured (AuthType), or undefined if no auth is configured
      */
-    getAuthType(): 'basic' | 'oauth' | undefined;
+    getAuthType(): AuthType | undefined;
     /**
      * Get ID token from OAuth authentication
      * @returns The ID token if OAuth auth is configured, undefined otherwise
@@ -765,15 +1554,6 @@ declare class NetworkServiceV3 {
      * @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
      *
@@ -808,7 +1588,7 @@ declare class NetworkServiceV3 {
     /**
      * Search networks with V3 enhanced features
      */
-    searchNetworks(searchParams?: SearchParameters): Promise<SearchResult>;
+    searchNetworks(searchParams?: SearchParameters): Promise<SearchResult<NetworkSummaryV3>>;
     /**
      * Get network as CX2Network object with utilities
      */
@@ -817,26 +1597,37 @@ declare class NetworkServiceV3 {
      * Create new network from CX2
      */
     createNetworkFromCX2(cx2Data: CX2Network$1 | CX2Network, options?: {
-        visibility?: 'PUBLIC' | 'PRIVATE';
-        name?: string;
-    }): Promise<{
-        uuid: string;
-    }>;
+        visibility?: Visibility;
+        folderId?: string;
+    }): Promise<NDExObjectUpdateStatus>;
     /**
      * Update network with CX2 data
      */
-    updateNetworkCX2(networkUUID: string, cx2Data: CX2Network$1 | CX2Network): Promise<void>;
+    updateNetworkCX2(networkUUID: string, cx2Data: CX2Network$1 | CX2Network): Promise<NDExObjectUpdateStatus>;
     /**
-     * Upload network file (CX2, CX, or other formats)
+     * Upload CX2 network via multipart/form-data
+     *
+     * Server endpoint: POST /v3/networks
+     * Consumes: multipart/form-data
+     * Form field: 'CXNetworkStream' (the CX2 content)
+     * Query params: visibility, folderId
+     * Returns: NdexObjectUpdateStatus
      */
-    uploadNetworkFile(file: File | Blob | string, options?: {
-        filename?: string;
-        visibility?: 'PUBLIC' | 'PRIVATE';
-        name?: string;
+    uploadCX2Network(cx2: File | Blob | Buffer | string | NodeJS.ReadableStream, options?: {
+        visibility?: Visibility;
+        folderId?: string;
         onProgress?: (progress: number) => void;
-    }): Promise<{
-        uuid: string;
-    }>;
+    }): Promise<NDExObjectUpdateStatus>;
+    /**
+     * Upload network file (Deprecated convenience wrapper)
+     *
+     * Delegates to uploadCX2Network(). Kept for backward compatibility.
+     */
+    uploadNetworkFile(file: File | Blob | Buffer | string | NodeJS.ReadableStream, options?: {
+        visibility?: Visibility;
+        onProgress?: (progress: number) => void;
+        folderId?: string;
+    }): Promise<NDExObjectUpdateStatus>;
     /**
      * Get network metadata (V3 enhanced)
      */
@@ -849,6 +1640,12 @@ declare class NetworkServiceV3 {
      * Get network aspect (specific CX2 aspect)
      */
     getNetworkAspect(networkUUID: string, aspectName: string, options?: AccessParams): Promise<any>;
+    /**
+       * Delete network
+       * @param networkUUID - The UUID of the network to delete
+       * @param permanent - If true, permanently delete the network. If false (default), soft delete to trash for 30 days
+       */
+    deleteNetwork(networkUUID: string, permanent?: boolean): Promise<void>;
 }
 
 /**
@@ -874,6 +1671,40 @@ declare class NetworkServiceV2 {
      * Get network summary by UUID
      */
     getNetworkSummary(networkUUID: string, options?: AccessParams): Promise<NetworkSummaryV2>;
+    /**
+     * Update network summary
+     *
+     * Updates the summary information for an existing network. This allows modification
+     * of network metadata such as name, description, visibility, and other summary properties
+     * without updating the actual network content (nodes/edges).
+     *
+     * @param networkUUID - The UUID of the network to update
+     * @param networkSummary - The updated network summary object containing the new metadata
+     * @returns Promise that resolves when the update is complete
+     *
+     * @example
+     * ```typescript
+     * // Update network name and description
+     * await networkService.updateNetworkSummary('12345678-1234-1234-1234-123456789abc', {
+     *   externalId: '12345678-1234-1234-1234-123456789abc',
+     *   name: 'Updated Network Name',
+     *   description: 'Updated network description',
+     *   nodeCount: 150,
+     *   edgeCount: 200,
+     *   visibility: 'PUBLIC',
+     *   owner: 'username',
+     *   ownerUUID: 'user-uuid',
+     *   creationTime: 1234567890,
+     *   modificationTime: 1234567890,
+     *   isReadOnly: false,
+     *   isValid: true,
+     *   hasLayout: true,
+     *   hasSample: false,
+     *   updatedBy: 'username'
+     * });
+     * ```
+     */
+    updateNetworkSummary(networkUUID: string, networkSummary: NetworkSummaryV2): Promise<void>;
     /**
     * Copy network
     *
@@ -916,7 +1747,7 @@ declare class NetworkServiceV2 {
      * @returns Promise resolving to the UUID string of the newly created network
      */
     createNetworkFromRawCX1(rawCX: any[], options?: {
-        visibility?: 'PUBLIC' | 'PRIVATE';
+        visibility?: Visibility;
     }): Promise<string>;
     /**
      * Update network from raw CX1 data
@@ -964,7 +1795,7 @@ declare class NetworkServiceV2 {
     /**
      * Grant network permission to user
      */
-    grantNetworkPermission(networkUUID: string, userUUID: string, permission: 'READ' | 'WRITE' | 'ADMIN'): Promise<void>;
+    grantNetworkPermission(networkUUID: string, userUUID: string, permission: Permission): Promise<void>;
     /**
      * Revoke network permission from user
      */
@@ -1057,9 +1888,78 @@ declare class UnifiedNetworkService {
     private v3Service;
     constructor(http: HTTPService);
     /**
-     * Get network summary using specified API version
+     * Get network summary using V3 API
+     *
+     * Retrieves comprehensive summary information for a network including metadata,
+     * statistics, permissions, and other network properties using the V3 API.
+     *
+     * @param networkUUID - The UUID of the network to get summary for
+     * @param options - Access options including optional access key for private networks
+     * @returns Promise resolving to NetworkSummaryV3 object containing network summary information
      */
     getNetworkSummary(networkUUID: string, options?: AccessParams): Promise<NetworkSummaryV3>;
+    /**
+     * Update network summary using V3 to V2 transformation
+     *
+     * Updates network summary information by accepting a NetworkSummaryV3 object,
+     * transforming it to the V2 format, and calling the V2 API endpoint.
+     * This provides a unified interface for updating network summaries while
+     * maintaining compatibility with the existing V2 backend infrastructure.
+     *
+     * @param networkUUID - The UUID of the network to update
+     * @param networkSummaryV3 - The updated network summary in V3 format
+     * @returns Promise that resolves when the update is complete
+     *
+     * @example
+     * ```typescript
+     * // Update network summary using V3 format
+     * const summaryV3: NetworkSummaryV3 = {
+     *   externalId: '12345678-1234-1234-1234-123456789abc',
+     *   name: 'Updated Network Name',
+     *   description: 'Updated network description',
+     *   nodeCount: 150,
+     *   edgeCount: 200,
+     *   visibility: 'PUBLIC',
+     *   owner: 'username',
+     *   ownerUUID: 'user-uuid',
+     *   creationTime: 1234567890,
+     *   modificationTime: 1234567890,
+     *   isReadOnly: false,
+     *   isValid: true,
+     *   hasLayout: true,
+     *   hasSample: false,
+     *   updatedBy: 'username',
+     *   properties: {
+     *     category: { t: 'string', v: 'biological' },
+     *     version: { t: 'double', v: 2.1 }
+     *   }
+     * };
+     *
+     * await client.networks.updateNetworkSummary('network-uuid', summaryV3);
+     * ```
+     */
+    updateNetworkSummary(networkUUID: string, networkSummaryV3: NetworkSummaryV3): Promise<void>;
+    /**
+     * Transform NetworkSummaryV3 to NetworkSummaryV2 format
+     *
+     * Converts V3 properties format (CX2-style object map) to V2 properties format (CX1-style array).
+     * This transformation is necessary because the V2 API expects properties in the older array format.
+     * Special handling for "version" attribute - moved to top-level version field.
+     *
+     * @param v3Summary - Network summary in V3 format with CX2-style properties
+     * @returns Network summary in V2 format with CX1-style properties
+     */
+    private transformV3ToV2;
+    /**
+     * Convert CX2 property values to strings
+     *
+     * For singleton values, converts to string directly.
+     * For list type values, converts each element to string.
+     *
+     * @param value - The CX2 property value (can be any type or array)
+     * @returns String representation of the value
+     */
+    private convertValueToString;
     /**
      * Search networks using specified API version
      * NOTE: This method is temporarily commented out as the V2 searchNetworks
@@ -1075,17 +1975,46 @@ declare class UnifiedNetworkService {
     getRawCX2Network(networkUUID: string, options?: AccessParams): Promise<CX2Network$1>;
     /**
      * Delete network
+     * @param networkUUID - The UUID of the network to delete
+     * @param permanent - If true, permanently delete the network. If false (default), soft delete to trash for 30 days
      */
-    deleteNetwork(networkUUID: string): Promise<void>;
+    deleteNetwork(networkUUID: string, permanent?: boolean): 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
+     * Requests a DOI (Digital Object Identifier) for a network. A reference is not required to request a DOI.
+     * If you want the ability to add or modify a reference later on, set `isCertified` to true.
+     * When certified, the network will be permanently locked, made publicly visible, and no further changes
+     * will be allowed.
+     *
+     * @param params - DOI request parameters
+     * @param params.networkId - UUID of the network to create a DOI for
+     * @param params.isCertified - If true, network will be permanently locked and made public with no further changes allowed
+     * @param params.contactEmail - Email address that the DOI creation confirmation should be sent to
+     * @returns Promise that resolves when the DOI request is submitted
+     *
+     * @example
+     * ```typescript
+     * // Request a DOI for a network without certification
+     * await client.networks.createNetworkDOI({
+     *   networkId: '12345678-1234-1234-1234-123456789abc',
+     *   isCertified: false,
+     *   contactEmail: 'user@example.com'
+     * });
+     *
+     * // Request a certified DOI (network will be permanently locked)
+     * await client.networks.createNetworkDOI({
+     *   networkId: '12345678-1234-1234-1234-123456789abc',
+     *   isCertified: true,
+     *   contactEmail: 'user@example.com'
+     * });
+     * ```
      */
-    createNetworkDOI(networkUUID: string, key: string, email: string): Promise<string>;
+    createNetworkDOI(params: {
+        networkId: string;
+        isCertified: boolean;
+        contactEmail: string;
+    }): Promise<void>;
     /**
      * Get attributes of selected nodes
      *
@@ -1183,20 +2112,71 @@ declare class UnifiedNetworkService {
      * @param folderId - Target folder ID to move networks to
      * @returns Promise resolving when networks are moved
      */
-    moveNetworks(networkIds: string[], folderId: string): Promise<any>;
+    moveNetworks(networkIds: string[], folderId?: string): Promise<any>;
     /**
-     * Set networks visibility (migrated from original NDEx.js)
+     * Set visibility for multiple files (networks, folders, shortcuts)
      *
-     * Changes visibility settings for multiple networks using the V3 API.
-     * Requires proper file validation to ensure data integrity.
+     * Changes visibility settings for multiple NDEx objects using the V3 API.
+     * This function can update visibility for any combination of networks, folders, and shortcuts.
+     * Files are validated to ensure proper UUID format and valid file types.
      *
-     * @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
+     * @param files - Object containing a 'files' property with UUID-to-filetype mappings
+     * @param files.files - Record where keys are UUIDs and values are NDExFileType ('NETWORK', 'FOLDER', or 'SHORTCUT')
+     * @param visibility - Visibility setting: 'PUBLIC', 'PRIVATE', or 'UNLISTED'
+     * @returns Promise resolving when visibility is successfully updated
+     * @throws Error if files validation fails or API request fails
+     *
+     * @example
+     * ```typescript
+     * // Set multiple files to public visibility
+     * await client.networks.setNetworksVisibility({
+     *   files: {
+     *     '12345678-1234-1234-1234-123456789abc': 'NETWORK',
+     *     '87654321-4321-4321-4321-876543210fed': 'FOLDER',
+     *     '11111111-2222-3333-4444-555555555555': 'SHORTCUT'
+     *   }
+     * }, 'PUBLIC');
+     *
+     * // Set networks to private visibility
+     * await client.networks.setNetworksVisibility({
+     *   files: {
+     *     'network-uuid-1': 'NETWORK',
+     *     'network-uuid-2': 'NETWORK'
+     *   }
+     * }, 'PRIVATE');
+     * ```
      */
     setNetworksVisibility(files: {
-        files: Record<string, 'NETWORK' | 'FOLDER' | 'SHORTCUT'>;
-    }, visibility: string): Promise<any>;
+        files: Record<string, NDExFileType>;
+    }, visibility: Visibility): Promise<any>;
+    /**
+     * Get network access key
+     *
+     * Retrieves the access key for a network if it has been enabled for public access.
+     * When a network has an access key enabled, it can be accessed by others without
+     * explicit permissions using this key.
+     *
+     * @param networkUUID - The UUID of the network to get the access key for
+     * @returns Promise resolving to an object with accessKey property when enabled,
+     *          or null when access key is not enabled on this network
+     *
+     * @example
+     * ```typescript
+     * // Check if network has an access key
+     * const result = await client.networks.getNetworkAccessKey('12345678-1234-1234-1234-123456789abc');
+     *
+     * if (result) {
+     *   console.log('Access key:', result.accessKey); // "sdfdfdfsdfdsfs"
+     *   // Use the access key to access the network
+     *   const networkData = await client.networks.getRawCX2Network(networkUUID, { accessKey: result.accessKey });
+     * } else {
+     *   console.log('No access key enabled for this network');
+     * }
+     * ```
+     */
+    getNetworkAccessKey(networkUUID: string): Promise<{
+        accessKey: string;
+    } | null>;
     /**
      * Get random edges from network (migrated from original NDEx.js)
      *
@@ -1211,13 +2191,13 @@ declare class UnifiedNetworkService {
      */
     getRandomEdges(networkUUID: string, limit: number, accessKey?: string): Promise<CX2Edge[]>;
     /**
-     * Validate share data format (helper method for file operations)
+     * Validate UUID format in file data (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.
+     * Validates that all UUID keys in the files object follow proper UUID format.
+     * TypeScript ensures object structure and file type validity at compile time.
      *
-     * @param data - Data object to validate (must contain 'files' property)
-     * @throws Error if validation fails
+     * @param data - Data object containing files property with UUID keys and NDExFileType values
+     * @throws Error if UUID validation fails
      */
     private validateShareData;
     /**
@@ -1303,28 +2283,33 @@ declare class UnifiedNetworkService {
     /**
      * 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.
+     * Creates a new network on NDEx from raw CX2 data using the V3 API.
+     * This function delegates to the NetworkServiceV3 implementation.
      *
-     * @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
+     * @param cx2Data - Raw CX2 network data as an object or CX2Network instance
+     * @param options - Creation options including visibility and folderId
+     * @param options.visibility - Network visibility: 'PUBLIC', 'PRIVATE', or 'UNLISTED' (default: 'PRIVATE')
+     * @param options.folderId - UUID of the folder to create the network in. If omitted, network is created in user's home directory
+     * @returns Promise resolving to NDExObjectUpdateStatus with uuid and modificationTime
      *
      * @example
      * ```typescript
-     * // Create private network from raw CX2 data
+     * // Create private network from raw CX2 data in user's home directory
      * 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);
+     * // Create public network from raw CX2 data in a specific folder
+     * const publicResult = await client.networks.createNetworkFromRawCX2(cx2Data, {
+     *   visibility: 'PUBLIC' as Visibility,
+     *   folderId: '87654321-4321-4321-4321-876543210fed'
+     * });
      * console.log(publicResult.uuid);
      * ```
      */
-    createNetworkFromRawCX2(rawCX2: CX2Network$1 | any, makePublic?: boolean): Promise<{
-        uuid: string;
-    }>;
+    createNetworkFromRawCX2(cx2Data: CX2Network$1 | CX2Network, options?: {
+        visibility?: Visibility;
+        folderId?: string;
+    }): Promise<NDExObjectUpdateStatus>;
     /**
      * Update network from raw CX2 data (migrated from original NDEx.js)
      *
@@ -1342,6 +2327,26 @@ declare class UnifiedNetworkService {
      * ```
      */
     updateNetworkFromRawCX2(networkUUID: string, rawCX2: CX2Network$1 | any): Promise<void>;
+    /**
+     * Set read-only flag on a network
+     *
+     * Sets or unsets the read-only flag for a network using the V2 API.
+     * When a network is marked as read-only, it cannot be modified.
+     *
+     * @param networkId - The UUID of the network to modify
+     * @param readOnly - true to set the network as read-only, false to allow modifications
+     * @returns Promise resolving when the read-only status is updated
+     *
+     * @example
+     * ```typescript
+     * // Set network as read-only
+     * await client.networks.setReadOnly('network-uuid', true);
+     *
+     * // Allow network modifications
+     * await client.networks.setReadOnly('network-uuid', false);
+     * ```
+     */
+    setReadOnly(networkId: string, readOnly: boolean): Promise<void>;
     /**
      * Access to underlying service instances for advanced usage
      */
@@ -1349,67 +2354,6 @@ declare class UnifiedNetworkService {
     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
  *
@@ -1611,9 +2555,9 @@ declare class UserService {
      * @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
+     * @returns Search result containing users matching the search criteria
      */
-    searchUsers(searchTerms: string, start?: number, size?: number): Promise<NDExUser[]>;
+    searchUsers(searchTerms: string, start?: number, size?: number): Promise<SearchResult<NDExUser>>;
     /**
      * Get networks for a user's account page (equivalent to getAccountPageNetworks from legacy client)
      *
@@ -1624,6 +2568,17 @@ declare class UserService {
      * @note This function requires authentication. The auth attribute must be set in the client configuration.
      */
     getAccountPageNetworks(userUUID: string, offset?: number, limit?: number): Promise<NetworkSummaryV2[]>;
+    /**
+     * Get User's Home Content
+     * Returns the content of a user's home folder including networks, folders, and shortcuts.
+     * Shows different content based on authentication status and relationship to the user.
+     *
+     * @param userUuid - User UUID to get home content for
+     * @param format - Format parameter: 'update' or 'compact' (default: "update")
+     * @returns List of file items in the user's home folder
+     * @note This function requires authentication. The auth attribute must be set in the client configuration.
+     */
+    getUserHomeContent(userUuid: string, format?: 'update' | 'compact'): Promise<FileListItem[]>;
     /**
      * Delete user account (server validates userid matches authenticated user)
      * @param userUUID - User UUID to delete (must match authenticated user)
@@ -1638,8 +2593,7 @@ declare class UserService {
  * Handles system administration and user management for admin users
  */
 declare class AdminService {
-    private http;
-    constructor(http: HTTPService);
+    constructor();
 }
 
 /**
@@ -1825,7 +2779,7 @@ declare class CyNDExService {
      * @param uuid - Target NDEx network UUID to update
      * @returns Promise resolving to update result
      */
-    putCytoscapeNetworkInNDEx(suid: string, uuid: string): Promise<any>;
+    putCytoscapeNetworkInNDEx(suid: string | undefined, uuid: string): Promise<any>;
 }
 
 /**
@@ -1842,14 +2796,14 @@ declare class CyNDExService {
  *   debug: true
  * });
  *
- * // Authenticate
- * await client.user.authenticate({ username: 'user', password: 'pass' });
+ * // Authenticate (requires auth config in constructor)
+ * const user = await client.user.authenticate();
  *
  * // Search networks
  * const results = await client.networks.searchNetworks({ searchString: 'pathway' });
  *
  * // Get network as CX2
- * const network = await client.networks.getNetworkAsCX2Object('network-uuid');
+ * const network = await client.networks.getRawCX2Network('network-uuid');
  *
  * // User operations
  * const profile = await client.user.getCurrentUser();
@@ -1913,9 +2867,16 @@ declare class NDExClient {
      */
     getConfig(): NDExClientConfig;
     /**
-     * Access to low-level HTTP service for advanced usage
+     * Get current authentication type
+     * @returns The type of authentication configured (AuthType), or undefined if no auth is configured
+     */
+    getAuthType(): AuthType | undefined;
+    /**
+     * Set ID token for OAuth authentication
+     * Creates OAuth auth configuration if no auth is currently configured
+     * @param idToken - The ID token to set
      */
-    get http(): HTTPService;
+    setIdToken(idToken: string): void;
     /**
      * Access to version-specific network services for advanced usage
      */
@@ -1926,6 +2887,29 @@ declare class NDExClient {
         networks: NetworkServiceV3;
     };
 }
+/**
+ * Library version string imported from package.json
+ *
+ * Provides programmatic access to the current library version for:
+ * - Runtime version checking and validation
+ * - Debugging and error reporting
+ * - Logging and telemetry
+ * - Version-dependent feature detection
+ *
+ * @example
+ * ```typescript
+ * import { NDExClient, version } from '@js4cytoscape/ndex-client';
+ *
+ * console.log(`Using NDEx Client v${version}`);
+ *
+ * // In error reports
+ * const errorReport = {
+ *   error: err.message,
+ *   libraryVersion: version,
+ *   timestamp: new Date().toISOString()
+ * };
+ * ```
+ */
 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 };
+export { type APIError, type APIResponse, type AccessKeyAction, type AccessKeyResponse, type AccessParams, AdminService, AuthType, 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, CXDataType, CyNDExService as CyNDEx, type CyNDExAuthConfig, type CyNDExConfig, CyNDExService, type CyNDExStatusResponse, type CyWebWorkspace, type CytoscapeNetworkSummary, type DefaultVisualProperties, type ExportFormat, type ExportRequest, type FileListItem, type FilePermissionDetails, type FilePermissionList, type FileSearchParams, FilesService, type MappingDefinition, type NDExAny, NDExAuthError, type NDExAuthResponse, NDExClient, type NDExClientConfig, NDExError, type NDExExportParams, NDExFileType, type NDExImportParams, NDExNetworkError, NDExNotFoundError, type NDExObjectUpdateStatus, NDExServerError, type NDExUser, NDExValidationError, NetworkIndexLevel, type NetworkPermission, NetworkServiceV2, NetworkServiceV3, type NetworkSummaryV2, type NetworkSummaryV3, type OAuthAuth, type PaginationParams, Permission, type SearchParameters, type SearchResult, type SharingMemberRequest, type Shortcut, type TableColumnVisualStyle, type Task, type Timestamp, type UUID, UnifiedNetworkService, UserService, VPMappingType, Visibility, type VisualPropertyMapping, type VisualPropertyTable, WorkspaceService, version };