@uipath/uipath-typescript 1.0.0-beta.18 → 1.0.0

package/dist/buckets/index.d.ts

@@ -0,0 +1,819 @@
+import { IUiPath } from '../core/index';
+
+/**
+ * Simplified universal pagination cursor
+ * Used to fetch next/previous pages
+ */
+interface PaginationCursor {
+    /** Opaque string containing all information needed to fetch next page */
+    value: string;
+}
+/**
+ * Discriminated union for pagination methods - ensures cursor and jumpToPage are mutually exclusive
+ */
+type PaginationMethodUnion = {
+    cursor?: PaginationCursor;
+    jumpToPage?: never;
+} | {
+    cursor?: never;
+    jumpToPage?: number;
+} | {
+    cursor?: never;
+    jumpToPage?: never;
+};
+/**
+ * Pagination options. Users cannot specify both cursor and jumpToPage.
+ */
+type PaginationOptions = {
+    /** Size of the page to fetch (items per page) */
+    pageSize?: number;
+} & PaginationMethodUnion;
+/**
+ * Paginated response containing items and navigation information
+ */
+interface PaginatedResponse<T> {
+    /** The items in the current page */
+    items: T[];
+    /** Total count of items across all pages (if available) */
+    totalCount?: number;
+    /** Whether more pages are available */
+    hasNextPage: boolean;
+    /** Cursor to fetch the next page (if available) */
+    nextCursor?: PaginationCursor;
+    /** Cursor to fetch the previous page (if available) */
+    previousCursor?: PaginationCursor;
+    /** Current page number (1-based, if available) */
+    currentPage?: number;
+    /** Total number of pages (if available) */
+    totalPages?: number;
+    /** Whether this pagination type supports jumping to arbitrary pages */
+    supportsPageJump: boolean;
+}
+/**
+ * Response for non-paginated calls that includes both data and total count
+ */
+interface NonPaginatedResponse<T> {
+    items: T[];
+    totalCount?: number;
+}
+/**
+ * Helper type for defining paginated method overloads
+ * Creates a union type of all ways pagination can be triggered
+ */
+type HasPaginationOptions<T> = (T & {
+    pageSize: number;
+}) | (T & {
+    cursor: PaginationCursor;
+}) | (T & {
+    jumpToPage: number;
+});
+
+/**
+ * Pagination types supported by the SDK
+ */
+declare enum PaginationType {
+    OFFSET = "offset",
+    TOKEN = "token"
+}
+/**
+ * Interface for service access methods needed by pagination helpers
+ */
+interface PaginationServiceAccess {
+    get<T>(path: string, options?: any): Promise<{
+        data: T;
+    }>;
+    post<T>(path: string, body?: any, options?: any): Promise<{
+        data: T;
+    }>;
+    requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
+}
+/**
+ * Field names for extracting data from paginated responses.
+ */
+interface PaginationFieldNames {
+    itemsField?: string;
+    totalCountField?: string;
+    continuationTokenField?: string;
+}
+/**
+ * Options for the requestWithPagination method in BaseService.
+ */
+interface RequestWithPaginationOptions extends RequestSpec {
+    pagination: PaginationFieldNames & {
+        paginationType: PaginationType;
+        paginationParams?: {
+            pageSizeParam?: string;
+            offsetParam?: string;
+            tokenParam?: string;
+            countParam?: string;
+        };
+    };
+}
+
+/**
+ * HTTP methods supported by the API client
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Supported response types for API requests
+ */
+type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
+/**
+ * Query parameters type with support for arrays and nested objects
+ */
+type QueryParams = Record<string, string | number | boolean | Array<string | number | boolean> | null | undefined>;
+/**
+ * Standard HTTP headers type
+ */
+type Headers = Record<string, string>;
+/**
+ * Options for request retries
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Base delay between retries in milliseconds */
+    retryDelay?: number;
+    /** Whether to use exponential backoff */
+    useExponentialBackoff?: boolean;
+    /** Status codes that should trigger a retry */
+    retryableStatusCodes?: number[];
+}
+/**
+ * Options for request timeouts
+ */
+interface TimeoutOptions {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Whether to abort the request on timeout */
+    abortOnTimeout?: boolean;
+}
+/**
+ * Options for request body transformation
+ */
+interface BodyOptions {
+    /** Whether to stringify the body */
+    stringify?: boolean;
+    /** Content type override */
+    contentType?: string;
+}
+/**
+ * Pagination metadata for API requests
+ */
+interface PaginationMetadata {
+    /** Type of pagination used by the API endpoint */
+    paginationType: PaginationType;
+    /** Response field containing items array (defaults to 'value') */
+    itemsField?: string;
+    /** Response field containing total count (defaults to '@odata.count') */
+    totalCountField?: string;
+    /** Response field containing continuation token (defaults to 'continuationToken') */
+    continuationTokenField?: string;
+}
+/**
+ * Base interface for all API requests
+ */
+interface RequestSpec {
+    /** HTTP method for the request */
+    method?: HttpMethod;
+    /** URL endpoint for the request */
+    url?: string;
+    /** Query parameters to be appended to the URL */
+    params?: QueryParams;
+    /** HTTP headers to include with the request */
+    headers?: Headers;
+    /** Raw body content (takes precedence over data) */
+    body?: unknown;
+    /** Expected response type */
+    responseType?: ResponseType;
+    /** Request timeout options */
+    timeoutOptions?: TimeoutOptions;
+    /** Retry behavior options */
+    retryOptions?: RetryOptions;
+    /** Body transformation options */
+    bodyOptions?: BodyOptions;
+    /** AbortSignal for cancelling the request */
+    signal?: AbortSignal;
+    /** Pagination metadata for the request */
+    pagination?: PaginationMetadata;
+}
+
+interface ApiResponse<T> {
+    data: T;
+}
+/**
+ * Base class for all UiPath SDK services.
+ *
+ * Provides common functionality for authentication, configuration, and API communication.
+ * All service classes extend this base to inherit dependency injection and HTTP client access.
+ *
+ * This class implements the dependency injection pattern where services receive a configured
+ * UiPath instance. The ApiClient is created internally and handles all HTTP operations
+ * including authentication token management.
+ *
+ * @remarks
+ * Service classes should extend this base and call `super(uiPath)` in their constructor.
+ * Protected HTTP methods (get, post, put, patch, delete) are available to all subclasses.
+ *
+ */
+declare class BaseService {
+    #private;
+    /**
+     * Creates a base service instance with dependency injection.
+     *
+     * Extracts configuration, execution context, and token manager from the UiPath instance
+     * to initialize an authenticated API client. The ApiClient handles all HTTP operations
+     * and token management internally.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration.
+     *                    Services receive this via dependency injection in the modular pattern.
+     *
+     * @example
+     * ```typescript
+     * // Services automatically call this via super()
+     * export class EntityService extends BaseService {
+     *   constructor(instance: IUiPath) {
+     *     super(instance); // Initializes the internal ApiClient
+     *   }
+     * }
+     *
+     * // Usage in modular pattern
+     * import { UiPath } from '@uipath/uipath-typescript/core';
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const sdk = new UiPath(config);
+     * await sdk.initialize();
+     * const entities = new Entities(sdk);
+     * ```
+     */
+    constructor(instance: IUiPath);
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Use this when you need to manually add Authorization headers (e.g., direct uploads).
+     *
+     * @returns Promise resolving to a valid access token string
+     * @throws AuthenticationError if no token is available or refresh fails
+     */
+    protected getValidAuthToken(): Promise<string>;
+    /**
+     * Creates a service accessor for pagination helpers
+     * This allows pagination helpers to access protected methods without making them public
+     */
+    protected createPaginationServiceAccess(): PaginationServiceAccess;
+    protected request<T>(method: string, path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected requestWithSpec<T>(spec: RequestSpec): Promise<ApiResponse<T>>;
+    protected get<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected post<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected put<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected patch<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected delete<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    /**
+     * Execute a request with cursor-based pagination
+     */
+    protected requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
+    /**
+     * Validates and prepares pagination parameters from options
+     */
+    private validateAndPreparePaginationParams;
+    /**
+     * Prepares request parameters for pagination based on pagination type
+     */
+    private preparePaginationRequestParams;
+    /**
+     * Creates a paginated response from API response
+     */
+    private createPaginatedResponseFromResponse;
+    /**
+     * Determines if there are more pages based on pagination type and metadata
+     */
+    private determineHasMorePages;
+}
+
+/**
+ * Base service for services that need folder-specific functionality.
+ *
+ * Extends BaseService with additional methods for working with folder-scoped resources
+ * in UiPath Orchestrator. Services that work with folders (Assets, Queues) extend this class.
+ *
+ * @remarks
+ * This class provides helper methods for making folder-scoped API calls, handling folder IDs
+ * in request headers, and managing cross-folder queries.
+ */
+declare class FolderScopedService extends BaseService {
+    /**
+     * Gets resources in a folder with optional query parameters
+     *
+     * @param endpoint - API endpoint to call
+     * @param folderId - required folder ID
+     * @param options - Query options
+     * @param transformFn - Optional function to transform the response data
+     * @returns Promise resolving to an array of resources
+     */
+    protected _getByFolder<T, R = T>(endpoint: string, folderId: number, options?: Record<string, any>, transformFn?: (item: T) => R): Promise<R[]>;
+}
+
+interface BaseOptions {
+    expand?: string;
+    select?: string;
+}
+/**
+ * Common request options interface used across services for querying data
+ */
+interface RequestOptions extends BaseOptions {
+    filter?: string;
+    orderby?: string;
+}
+
+declare enum BucketOptions {
+    None = "None",
+    ReadOnly = "ReadOnly",
+    AuditReadAccess = "AuditReadAccess",
+    AccessDataThroughOrchestrator = "AccessDataThroughOrchestrator"
+}
+interface BucketGetResponse {
+    id: number;
+    name: string;
+    description: string | null;
+    identifier: string;
+    storageProvider: string | null;
+    storageParameters: string | null;
+    storageContainer: string | null;
+    options: BucketOptions;
+    credentialStoreId: number | null;
+    externalName: string | null;
+    password: string | null;
+    foldersCount: number;
+}
+type BucketGetAllOptions = RequestOptions & PaginationOptions & {
+    folderId?: number;
+};
+type BucketGetByIdOptions = BaseOptions;
+/**
+ * Maps header names to their values
+ *
+ * @example
+ * ```typescript
+ * {
+ *   "x-ms-blob-type": "BlockBlob"
+ * }
+ * ```
+ */
+type ResponseDictionary = Record<string, string>;
+/**
+ * Response from the GetReadUri API
+ */
+interface BucketGetUriResponse {
+    /**
+     * The URI for accessing the blob file
+     */
+    uri: string;
+    /**
+     * HTTP method to use with the URI
+     */
+    httpMethod: string;
+    /**
+     * Whether authentication is required to access the URI
+     */
+    requiresAuth: boolean;
+    /**
+     * Headers to be included in the request
+     */
+    headers: ResponseDictionary;
+}
+interface BucketGetUriOptions extends BaseOptions {
+    /**
+     * The ID of the bucket
+     */
+    bucketId: number;
+    /**
+     * The ID of the folder
+     */
+    folderId: number;
+    /**
+     * The full path to the BlobFile
+     */
+    path: string;
+    /**
+     * URL expiration time in minutes (0 for default)
+     */
+    expiryInMinutes?: number;
+}
+/**
+ * Request options for getting a read URI for a file in a bucket
+ */
+type BucketGetReadUriOptions = BucketGetUriOptions;
+/**
+ * Request options for getting files in a bucket
+ */
+interface BucketGetFileMetaDataOptions {
+    /**
+     * The path prefix to filter files by
+     */
+    prefix?: string;
+}
+/**
+ * Request options for getting files in a bucket with pagination support
+ */
+type BucketGetFileMetaDataWithPaginationOptions = BucketGetFileMetaDataOptions & PaginationOptions;
+/**
+ * Response from the GetFiles API
+ */
+interface BucketGetFileMetaDataResponse {
+    /**
+     * Array of blob items in the bucket
+     */
+    blobItems: BlobItem[];
+    /**
+     * Token for retrieving the next set of results
+     */
+    continuationToken: string | null;
+}
+/**
+ * Represents a file or blob in a bucket
+ */
+interface BlobItem {
+    /**
+     * Full path to the blob
+     */
+    path: string;
+    /**
+     * Content type of the blob
+     */
+    contentType: string;
+    /**
+     * Size of the blob in bytes
+     */
+    size: number;
+    /**
+     * Last modified timestamp
+     */
+    lastModified: string | null;
+}
+/**
+ * Options for uploading files to a bucket
+ */
+interface BucketUploadFileOptions {
+    /**
+     * The ID of the bucket to upload to
+     */
+    bucketId: number;
+    /**
+     * The folder/organization unit ID for context
+     */
+    folderId: number;
+    /**
+     * Path where the file should be stored in the bucket
+     */
+    path: string;
+    /**
+     * File content to upload
+     */
+    content: Blob | Uint8Array<ArrayBuffer> | File;
+}
+/**
+ * Response from file upload operations
+ */
+interface BucketUploadResponse {
+    /**
+     * Whether the upload was successful
+     */
+    success: boolean;
+    /**
+     * HTTP status code from the upload operation
+     */
+    statusCode: number;
+}
+
+/**
+ * Service for managing UiPath storage Buckets.
+ *
+ * Buckets are cloud storage containers that can be used to store and manage files used by automation processes. [UiPath Buckets Guide](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/about-storage-buckets)
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { Buckets } from '@uipath/uipath-typescript/buckets';
+ *
+ * const buckets = new Buckets(sdk);
+ * const allBuckets = await buckets.getAll();
+ * ```
+ */
+interface BucketServiceModel {
+    /**
+     * Gets all buckets across folders with optional filtering
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with data and totalCount (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId and pagination options
+     * @returns Promise resolving to either an array of buckets NonPaginatedResponse<BucketGetResponse> or a PaginatedResponse<BucketGetResponse> when pagination options are used.
+     * {@link BucketGetResponse}
+     * @example
+     * ```typescript
+     * // Get all buckets across folders
+     * const allBuckets = await buckets.getAll();
+     *
+     * // Get buckets within a specific folder
+     * const folderBuckets = await buckets.getAll({
+     *   folderId: <folderId>
+     * });
+     *
+     * // Get buckets with filtering
+     * const filteredBuckets = await buckets.getAll({
+     *   filter: "name eq 'MyBucket'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await buckets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends BucketGetAllOptions = BucketGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BucketGetResponse> : NonPaginatedResponse<BucketGetResponse>>;
+    /**
+     * Gets a single bucket by ID
+     *
+     * @param bucketId - Bucket ID
+     * @param folderId - Required folder ID
+     * @param options - Optional query parameters
+     * @returns Promise resolving to a bucket definition
+     * {@link BucketGetResponse}
+     * @example
+     * ```typescript
+     * // Get bucket by ID
+     * const bucket = await buckets.getById(<bucketId>, <folderId>);
+     * ```
+     */
+    getById(bucketId: number, folderId: number, options?: BucketGetByIdOptions): Promise<BucketGetResponse>;
+    /**
+     * Gets metadata for files in a bucket with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param bucketId - The ID of the bucket to get file metadata from
+     * @param folderId - Required folder ID for organization unit context
+     * @param options - Optional parameters for filtering, pagination and access URL generation
+     * @returns Promise resolving to either an array of files metadata NonPaginatedResponse<BlobItem> or a PaginatedResponse<BlobItem> when pagination options are used.
+     * {@link BlobItem}
+     * @example
+     * ```typescript
+     * // Get metadata for all files in a bucket
+     * const fileMetadata = await buckets.getFileMetaData(<bucketId>, <folderId>);
+     *
+     * // Get file metadata with a specific prefix
+     * const prefixMetadata = await buckets.getFileMetaData(<bucketId>, <folderId>, {
+     *   prefix: '/folder1'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getFileMetaData(<bucketId>, <folderId>, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getFileMetaData(<bucketId>, <folderId>, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getFileMetaData<T extends BucketGetFileMetaDataWithPaginationOptions = BucketGetFileMetaDataWithPaginationOptions>(bucketId: number, folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BlobItem> : NonPaginatedResponse<BlobItem>>;
+    /**
+     * Gets a direct download URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path and optional expiry time
+     * @returns Promise resolving to blob file access information
+     * {@link BucketGetUriResponse}
+     * @example
+     * ```typescript
+     * // Get download URL for a file
+     * const fileAccess = await buckets.getReadUri({
+     *   bucketId: <bucketId>,
+     *   folderId: <folderId>,
+     *   path: '/folder/file.pdf'
+     * });
+     * ```
+     */
+    getReadUri(options: BucketGetReadUriOptions): Promise<BucketGetUriResponse>;
+    /**
+     * Uploads a file to a bucket
+     *
+     * @param options - Options for file upload including bucket ID, folder ID, path, content, and optional parameters
+     * @returns Promise resolving bucket upload response
+     * {@link BucketUploadResponse}
+     * @example
+     * ```typescript
+     * // Upload a file from browser
+     * const file = new File(['file content'], 'example.txt');
+     * const result = await buckets.uploadFile({
+     *   bucketId: <bucketId>,
+     *   folderId: <folderId>,
+     *   path: '/folder/example.txt',
+     *   content: file
+     * });
+     *
+     * // In Node env with Uint8Array or Buffer
+     * const content = new TextEncoder().encode('file content');
+     * const result = await buckets.uploadFile({
+     *   bucketId: <bucketId>,
+     *   folderId: <folderId>,
+     *   path: '/folder/example.txt',
+     *   content,
+     * });
+     * ```
+     */
+    uploadFile(options: BucketUploadFileOptions): Promise<BucketUploadResponse>;
+}
+
+declare class BucketService extends FolderScopedService implements BucketServiceModel {
+    /**
+     * Gets a bucket by ID
+     * @param bucketId - The ID of the bucket to retrieve
+     * @param folderId - Folder ID for organization unit context
+     * @param options - Optional query parameters (expand, select)
+     * @returns Promise resolving to the bucket
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Get bucket by ID
+     * const bucket = await buckets.getById(123, 456);
+     * ```
+     */
+    getById(id: number, folderId: number, options?: BucketGetByIdOptions): Promise<BucketGetResponse>;
+    /**
+     * Gets all buckets across folders with optional filtering and folder scoping
+     *
+     * The method returns either:
+     * - An array of buckets (when no pagination parameters are provided)
+     * - A paginated result with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param options - Query options including optional folderId
+     * @returns Promise resolving to an array of buckets or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Get all buckets across folders
+     * const allBuckets = await buckets.getAll();
+     *
+     * // Get buckets within a specific folder
+     * const folderBuckets = await buckets.getAll({
+     *   folderId: 123
+     * });
+     *
+     * // Get buckets with filtering
+     * const filteredBuckets = await buckets.getAll({
+     *   filter: "name eq 'MyBucket'"
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getAll({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page5 = await buckets.getAll({
+     *   jumpToPage: 5,
+     *   pageSize: 10
+     * });
+     * ```
+     */
+    getAll<T extends BucketGetAllOptions = BucketGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BucketGetResponse> : NonPaginatedResponse<BucketGetResponse>>;
+    /**
+     * Gets metadata for files in a bucket with optional filtering and pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param bucketId - The ID of the bucket to get file metadata from
+     * @param folderId - Required folder ID for organization unit context
+     * @param options - Optional parameters for filtering, pagination and access URL generation
+     * @returns Promise resolving to the list of file metadata in the bucket or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Get metadata for all files in a bucket
+     * const fileMetadata = await buckets.getFileMetaData(123, 456);
+     *
+     * // Get file metadata with a specific prefix
+     * const fileMetadata = await buckets.getFileMetaData(123, 456, {
+     *   prefix: '/folder1'
+     * });
+     *
+     * // First page with pagination
+     * const page1 = await buckets.getFileMetaData(123, 456, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await buckets.getFileMetaData(123, 456, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getFileMetaData<T extends BucketGetFileMetaDataWithPaginationOptions = BucketGetFileMetaDataWithPaginationOptions>(bucketId: number, folderId: number, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<BlobItem> : NonPaginatedResponse<BlobItem>>;
+    /**
+     * Uploads a file to a bucket
+     *
+     * @param options - Options for file upload including bucket ID, folder ID, path, content, and optional parameters
+     * @returns Promise resolving to a response with success status and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Upload a file from browser
+     * const file = new File(['file content'], 'example.txt');
+     * const result = await buckets.uploadFile({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/example.txt',
+     *   content: file
+     * });
+     *
+     * // In Node env with Buffer
+     * const buffer = Buffer.from('file content');
+     * const result = await buckets.uploadFile({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/example.txt',
+     *   content: buffer
+     * });
+     * ```
+     */
+    uploadFile(options: BucketUploadFileOptions): Promise<BucketUploadResponse>;
+    /**
+     * Gets a direct download URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path and optional expiry time
+     * @returns Promise resolving to blob file access information
+     *
+     * @example
+     * ```typescript
+     * import { Buckets } from '@uipath/uipath-typescript/buckets';
+     *
+     * const buckets = new Buckets(sdk);
+     *
+     * // Get download URL for a file
+     * const fileAccess = await buckets.getReadUri({
+     *   bucketId: 123,
+     *   folderId: 456,
+     *   path: '/folder/file.pdf'
+     * });
+     * ```
+     */
+    getReadUri(options: BucketGetReadUriOptions): Promise<BucketGetUriResponse>;
+    /**
+     * Uploads content to the provided URI
+     * @param uriResponse - Response from getWriteUri containing URL and headers
+     * @param content - The content to upload
+     * @returns The response from the upload request with status info
+     */
+    private _uploadToUri;
+    /**
+     * Private method to handle common URI request logic
+     * @param endpoint - The API endpoint to call
+     * @param bucketId - The bucket ID
+     * @param folderId - The folder ID
+     * @param path - The file path
+     * @param queryOptions - Additional query parameters
+     * @returns Promise resolving to blob file access information
+     */
+    private _getUri;
+    /**
+     * Gets a direct upload URL for a file in the bucket
+     *
+     * @param options - Contains bucketId, folderId, file path, optional expiry time
+     * @returns Promise resolving to blob file access information
+     */
+    private _getWriteUri;
+}
+
+export { BucketOptions, BucketService, BucketService as Buckets };
+export type { BlobItem, BucketGetAllOptions, BucketGetByIdOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, ResponseDictionary };