@progress/sitefinity-webservices-sdk 1.1.16 → 2.0.0

package/src/Sitefinity.d.ts

@@ -0,0 +1,141 @@
+import { Data } from "./Data";
+import { Query } from "./Query";
+import { ResponseHandlers } from "./Requests/ExecutableRequest";
+import { BatchRequest } from "./Requests/BatchRequest";
+import { HttpTransport } from "./Transport/HttpTransport";
+/**
+ * Entry point for querying and modifying content through the Sitefinity Web Services API.
+ */
+export declare class Sitefinity {
+    /**
+     * Query builder constructor exposed for consumers that need to build OData queries.
+     */
+    static Query: typeof Query;
+    private factory;
+    private baseUrl;
+    private siteId;
+    /**
+     * Creates the SDK entry point.
+     *
+     * @param options Service URL and optional site-level configuration.
+     */
+    constructor(options: SDKOptions);
+    /**
+     * Creates a data client for an entity set.
+     *
+     * The returned client uses the SDK defaults unless a URL, provider, culture, site,
+     * query parameters, or headers are overridden in `options`.
+     *
+     * @param options Entity-set and request URL options.
+     * @returns A data client for the requested entity set.
+     *
+     * @example
+     * const news = sdk.data({ entitySet: "newsitems", culture: "en" });
+     * news.get({ successCb: items => console.log(items) });
+     */
+    data(options: TypeOptions): Data;
+    /**
+     * Creates a batch for grouping requests and optional upload, update, or workflow operations.
+     *
+     * Call `execute()` after adding requests. The callbacks receive the batch response,
+     * failure payload, and progress event respectively. Batch options override SDK URL options.
+     *
+     * @param success Callback invoked when the batch succeeds.
+     * @param failure Callback invoked when the batch fails.
+     * @param progress Callback invoked as request progress is reported.
+     * @param options Optional URL and request options for the batch.
+     * @returns A batch request that can be populated and executed.
+     */
+    batch(success?: Function, failure?: Function, progress?: Function, options?: TypeOptions): BatchRequest;
+    /**
+     * Sets the value sent in the `Authorization` header.
+     *
+     * The current token form is `{ type, value }`, for example
+     * `{ type: "Bearer", value: "token" }`. A raw string is also accepted at runtime
+     * for backward compatibility and is sent unchanged.
+     *
+     * @param token Token object or legacy raw authorization header value.
+     */
+    setToken(token: AuthorizationToken): void;
+}
+interface OptionsBase {
+    /**
+     * Service URL that points to the configured Sitefinity service.
+     */
+    baseUrl?: string;
+    /**
+     * ID of the site for which requests are executed.
+     */
+    siteId?: string;
+}
+/**
+ * Configuration options for the SDK entry point.
+ */
+export interface SDKOptions extends OptionsBase {
+    /**
+     * Default callbacks used when a request does not provide its own callback.
+     */
+    handlers?: ResponseHandlers;
+    /**
+     * Adds the Sitefinity unlimited-choices request header when true.
+     */
+    enableUnlimitedChoices?: boolean;
+    /**
+     * Adds the Sitefinity integration-mode request header when true.
+     */
+    integrationMode?: boolean;
+    /**
+     * Sends every HTTP request the SDK makes. Use it to route SDK traffic through your own HTTP stack,
+     * such as Angular's `HttpClient` or `fetch`. Defaults to {@link XhrTransport}, which uses `XMLHttpRequest`.
+     */
+    transport?: HttpTransport;
+}
+/**
+ * Configuration options for an entity-set data client or batch.
+ */
+export interface TypeOptions extends OptionsBase {
+    /**
+     * URL name of the entity set, such as `"newsitems"` or `"images"`.
+     */
+    entitySet?: string;
+    /**
+     * Provider name. When omitted, Sitefinity uses the site's default provider.
+     */
+    provider?: string;
+    /**
+     * Culture name. When omitted, Sitefinity uses the site's default culture.
+     */
+    culture?: string;
+    /**
+     * Additional query-string values appended to each request URL.
+     */
+    additionalQueryParams?: {
+        [key: string]: string;
+    };
+    /**
+     * Additional headers sent with each request.
+     */
+    additionalHeaders?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Structured authorization token.
+ *
+ * `setToken` also accepts a raw string at runtime for backward compatibility.
+ */
+export interface Token {
+    /**
+     * Authorization scheme, such as `"Bearer"`.
+     */
+    type: string;
+    /**
+     * Token value.
+     */
+    value: string;
+}
+/**
+ * Structured authorization token or a legacy raw `Authorization` header value.
+ */
+export type AuthorizationToken = Token | string;
+export {};

package/src/Transport/FetchTransport.d.ts

@@ -0,0 +1,17 @@
+import { HttpTransport, HttpTransportRequest, HttpTransportResponse } from "./HttpTransport";
+/**
+ * Transport that sends requests with the Fetch API.
+ *
+ * Fetch cannot report upload progress, so `onUploadProgress` is never called.
+ */
+export declare class FetchTransport implements HttpTransport {
+    private readonly fetchImplementation;
+    /**
+     * Creates a fetch-based transport.
+     *
+     * @param fetchImplementation Fetch function to use. Defaults to the global `fetch`, resolved when sending.
+     */
+    constructor(fetchImplementation?: typeof fetch);
+    /** Sends the request with `fetch`. A failure to get any response is reported with status `0`. */
+    send(request: HttpTransportRequest, onComplete: (response: HttpTransportResponse) => void): void;
+}

package/src/Transport/HttpTransport.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Upload progress reported by a transport.
+ *
+ * A DOM `ProgressEvent` satisfies this shape.
+ */
+export interface HttpTransportProgressEvent {
+    /** Whether `total` is known. */
+    lengthComputable: boolean;
+    /** Amount sent so far. */
+    loaded: number;
+    /** Total amount to send. */
+    total: number;
+}
+/**
+ * A request the SDK asks a transport to send.
+ */
+export interface HttpTransportRequest {
+    /** HTTP method, such as `GET` or `POST`. */
+    method: string;
+    /** Absolute URL including the query string. */
+    url: string;
+    /** Header names and values. A transport must send every entry. */
+    headers: {
+        [name: string]: string;
+    };
+    /** JSON text, or a `Blob` for uploads. Absent for requests without content. */
+    body?: string | Blob;
+    /**
+     * Present only when the caller wants upload progress. A transport that can report progress
+     * must not subscribe to it when this is absent. A transport that cannot report progress ignores it.
+     */
+    onUploadProgress?: (event: HttpTransportProgressEvent) => void;
+}
+/**
+ * The outcome of a request, as the SDK needs it.
+ */
+export interface HttpTransportResponse {
+    /**
+     * HTTP status code, or `0` when no response was received, for example after a network failure.
+     * The SDK invokes neither its success nor its failure callback for `0`.
+     */
+    status: number;
+    /** Response body as text. */
+    body: string;
+    /** Response headers keyed by lower-case name. */
+    headers: {
+        [name: string]: string;
+    };
+}
+/**
+ * Sends the HTTP requests the SDK builds.
+ *
+ * Pass an implementation as `SDKOptions.transport` to route all SDK traffic through your own HTTP stack,
+ * such as Angular's `HttpClient`, `fetch`, or a test double. When none is supplied the SDK uses
+ * {@link XhrTransport}.
+ */
+export interface HttpTransport {
+    /**
+     * Sends a request and calls `onComplete` exactly once, with whatever status the server returned,
+     * including error statuses. The SDK decides which statuses are successes or failures.
+     *
+     * `onComplete` may be called synchronously. The SDK's own callbacks run inside it, so the timing
+     * of the SDK's callbacks follows the transport's.
+     *
+     * @param request The request to send.
+     * @param onComplete Called with the response once the request finishes.
+     */
+    send(request: HttpTransportRequest, onComplete: (response: HttpTransportResponse) => void): void;
+}

package/src/Transport/XhrTransport.d.ts

@@ -0,0 +1,8 @@
+import { HttpTransport, HttpTransportRequest, HttpTransportResponse } from "./HttpTransport";
+/**
+ * Default transport. Sends requests with `XMLHttpRequest`.
+ */
+export declare class XhrTransport implements HttpTransport {
+    /** Sends the request with a new `XMLHttpRequest` and reports its final state. */
+    send(request: HttpTransportRequest, onComplete: (response: HttpTransportResponse) => void): void;
+}

package/src/WhereQuery.d.ts

@@ -0,0 +1,88 @@
+import { ComplexExpression } from "./Expression";
+/**
+ * Fluent builder for a query's `$filter` expression.
+ *
+ * Comparison methods add conditions to the current logical group and return
+ * the same builder. Logical methods create nested groups; call `done()` once
+ * for each group to return to the parent query or group.
+ *
+ * Supported comparisons are `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`,
+ * `startsWith`, `contains`, and `endsWith`. Values are serialized by the query
+ * builder when the query is built.
+ *
+ * @typeParam QueryType The parent type returned by `done()`.
+ */
+export declare class WhereQuery<QueryType> {
+    private parent;
+    private expression;
+    /** Creates a logical group attached to the supplied parent. */
+    constructor(parent: QueryType, type?: string);
+    /**
+     * Starts a nested `and` group.
+     * @returns A nested builder whose `done()` returns this group.
+     */
+    and(): WhereQuery<WhereQuery<QueryType>>;
+    /**
+     * Starts a nested `or` group.
+     * @returns A nested builder whose `done()` returns this group.
+     */
+    or(): WhereQuery<WhereQuery<QueryType>>;
+    /**
+     * Starts an OData `any` group for collection-valued properties.
+     * @returns A nested builder whose `done()` returns this group.
+     */
+    any(): WhereQuery<WhereQuery<QueryType>>;
+    /**
+     * Starts a negated group.
+     * @returns A nested builder whose `done()` returns this group.
+     * @throws Error If more than one direct condition is added to the group.
+     */
+    not(): WhereQuery<WhereQuery<QueryType>>;
+    /**
+     * Adds an equality condition.
+     * @param parameter Property name.
+     * @param constant Value to compare with.
+     * @returns This filter builder.
+     */
+    eq(parameter: string, constant: any): WhereQuery<QueryType>;
+    /**
+     * Adds an inequality condition.
+     * @param parameter Property name.
+     * @param constant Value to compare with.
+     * @returns This filter builder.
+     */
+    ne(parameter: string, constant: any): WhereQuery<QueryType>;
+    /** Adds a greater-than condition for number, string, or date values. */
+    gt(parameter: string, constant: any): WhereQuery<QueryType>;
+    /** Adds a greater-than-or-equal condition for number, string, or date values. */
+    gte(parameter: string, constant: any): WhereQuery<QueryType>;
+    /** Adds a less-than condition for number, string, or date values. */
+    lt(parameter: string, constant: any): WhereQuery<QueryType>;
+    /** Adds a less-than-or-equal condition for number, string, or date values. */
+    lte(parameter: string, constant: any): WhereQuery<QueryType>;
+    /** Adds a string-prefix condition, optionally using case-insensitive matching. */
+    startsWith(parameter: string, constant: any, caseSensitive?: boolean): WhereQuery<QueryType>;
+    /** Adds a string-contains condition, optionally using case-insensitive matching. */
+    contains(parameter: string, constant: any, caseSensitive?: boolean): WhereQuery<QueryType>;
+    /** Adds a string-suffix condition, optionally using case-insensitive matching. */
+    endsWith(parameter: string, constant: any, caseSensitive?: boolean): WhereQuery<QueryType>;
+    /**
+     * Adds an OData `in` condition.
+     *
+     * The constant must be an array; otherwise `build()` throws an error.
+     */
+    in(parameter: string, constant: any): WhereQuery<QueryType>;
+    /**
+     * Completes this group and returns its parent.
+     *
+     * Call once for the root filter to return to `Query`, and once for each
+     * nested group to continue the surrounding chain.
+     *
+     * @returns The parent query or enclosing filter group.
+     */
+    done(): QueryType;
+    /** Returns the expression tree represented by this filter group. */
+    getExpression(): ComplexExpression;
+    private simple;
+    private addComplexExpression;
+}

package/src/chunk-upload/chunk-upload.sdk.d.ts

@@ -0,0 +1,305 @@
+import { CreateRequestOptions } from "../Data";
+import { RequestFactory } from "../Requests/RequestFactory";
+import { TypeOptions } from "../Sitefinity";
+import { ChunkFileResult } from "./chunked-file-upload.utilities";
+/**
+ * Provides the client-side workflow for uploading a file in chunks.
+ *
+ * A typical upload calls `getChunkUploadInfo`, uses the returned session and
+ * chunk settings with `uploadChunk`, and then calls `commitChunks`. If an
+ * upload cannot be completed, call `cleanUpChunks` to remove the server-side
+ * chunks. Use `chunkFile` to split a `Blob` or base64 string before uploading.
+ */
+export declare class ChunkUploadSdk {
+    private urlOptions;
+    private factory;
+    constructor(urlOptions: TypeOptions, factory: RequestFactory);
+    /**
+     * Gets the session, provider, and chunk settings required to start an upload.
+     *
+     * The `data.libraryId` field must identify the parent library, not a library
+     * folder. The inherited callbacks and query options are optional.
+     *
+     * @param parameters Request data and optional callbacks.
+     * @param parameters.data.libraryId Parent library identifier.
+     * @param parameters.successCb Receives a {@link ChunkUploadInfoDTO} on success.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives upload progress events when supported.
+     */
+    getChunkUploadInfo(parameters: GetChunkUploadInfoRequestOptions): void;
+    /**
+     * Sends one chunk to the server.
+     *
+     * Upload chunks in ordinal order from `0` through `numberOfChunks - 1`.
+     * `chunkSize` is the chunk size in bytes, while `chunkBlob` contains the
+     * current chunk and may be smaller for the final chunk. The session,
+     * provider, ordinal, count, size, and blob fields are required.
+     *
+     * @param parameters Chunk data and optional callbacks.
+     * @param parameters.data.fileMimeType MIME type of the complete file.
+     * @param parameters.data.fileName File name sent with the chunk.
+     * @param parameters.data.chunkedFileUploadSessionId Session from
+     * `getChunkUploadInfo`.
+     * @param parameters.data.chunkSize Size of this chunk in bytes.
+     * @param parameters.data.chunkOrdinal Zero-based ordinal of this chunk.
+     * @param parameters.data.numberOfChunks Total chunks in the upload.
+     * @param parameters.data.positionOfChunkInQueue Optional queue position used
+     * to calculate progress for concurrent uploads.
+     * @param parameters.data.chunkBlob Bytes for this chunk.
+     * @param parameters.data.blobStorageProviderName Provider from the upload info.
+     * @param parameters.successCb Receives a {@link ChunkUploadResult} on success.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives upload progress events when supported.
+     */
+    uploadChunk(parameters: UploadChunkRequestOptions): void;
+    /**
+     * Commits all uploaded chunks as one media file.
+     *
+     * Call this only after every ordinal has uploaded successfully. The server
+     * validates `numberOfChunks` and `fileTotalSize` before assembling the file.
+     * Set `data.itemId` when replacing an existing media item; omit it when
+     * creating a new item. A successful commit completes the upload session.
+     *
+     * @param parameters Commit data and optional callbacks.
+     * @param parameters.data.chunkedFileUploadSessionId Session used by the chunks.
+     * @param parameters.data.contentType MIME type of the complete file.
+     * @param parameters.data.fileTotalSize Complete file size in bytes.
+     * @param parameters.data.numberOfChunks Number of uploaded chunks.
+     * @param parameters.data.name File name.
+     * @param parameters.data.blobStorageProviderName Provider used for the chunks.
+     * @param parameters.data.uploadProperties Media item properties such as
+     * `Title` and `UrlName`.
+     * @param parameters.data.itemId Optional existing item identifier for updates.
+     * @param parameters.successCb Receives the commit response on success.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives upload progress events when supported.
+     */
+    commitChunks(parameters: CommitChunksRequestOptions): void;
+    /**
+     * Deletes all chunks associated with an incomplete upload session.
+     *
+     * Call this after a failed chunk upload or failed commit when the session
+     * should not be resumed. Cleanup does not commit a file and requires the
+     * session and provider used by the upload.
+     *
+     * @param parameters Session data and optional callbacks.
+     * @param parameters.data.chunkedFileUploadSessionId Session to clean up.
+     * @param parameters.data.blobStorageProviderName Provider holding the chunks.
+     * @param parameters.successCb Called after cleanup succeeds.
+     * @param parameters.failureCb Receives the server error response on failure.
+     * @param parameters.progressCb Receives request progress events when supported.
+     */
+    cleanUpChunks(parameters: CleanUpChunksRequestOptions): void;
+    /**
+     * Splits a file into uploadable chunks.
+     *
+     * A `Blob` is sliced directly. A base64 string is decoded with `atob` into
+     * a `Blob` using `contentTypeMime`, then sliced. Each returned chunk has a
+     * zero-based ordinal, and the last chunk can be smaller than `chunkSize`.
+     *
+     * @param file Source `Blob` or base64-encoded binary string.
+     * @param chunkSize Maximum chunk size in bytes.
+     * @param contentTypeMime MIME type assigned to the chunks and decoded Blob.
+     * @returns Chunk blobs, their zero-based ordinals, total count, and file size.
+     *
+     * @example
+     * ```ts
+     * const upload = sitefinity.data(typeOptions).chunkUpload;
+     * const result = upload.chunkFile(file, 5 * 1024 * 1024, "image/jpeg");
+     *
+     * for (const chunk of result.chunks) {
+     *     upload.uploadChunk({
+     *         data: {
+     *             fileMimeType: "image/jpeg",
+     *             chunkedFileUploadSessionId: sessionId,
+     *             chunkSize: chunk.content.size,
+     *             chunkOrdinal: chunk.ordinal,
+     *             numberOfChunks: result.totalChunksCount,
+     *             chunkBlob: chunk.content,
+     *             blobStorageProviderName: providerName
+     *         },
+     *         successCb: onChunkUploaded,
+     *         failureCb: onUploadFailed
+     *     });
+     * }
+     * ```
+     */
+    chunkFile(file: Blob | string, chunkSize: number, contentTypeMime: string): ChunkFileResult;
+}
+/**
+ * Options for uploading one file chunk.
+ *
+ * The inherited `successCb`, `failureCb`, `progressCb`, `query`, and
+ * `fallbackProperties` fields are optional. All fields in `data` are required
+ * except `positionOfChunkInQueue`.
+ */
+export interface UploadChunkRequestOptions extends CreateRequestOptions {
+    /**
+     * Values used to construct the chunk request.
+     */
+    data: {
+        /**
+         * MIME type of the complete file.
+         */
+        fileMimeType: string;
+        /**
+         * File name sent with the chunk.
+         */
+        fileName: string;
+        /**
+         * Session identifier returned by `getChunkUploadInfo`.
+         */
+        chunkedFileUploadSessionId: string;
+        /**
+         * Size of this chunk in bytes.
+         */
+        chunkSize: number;
+        /**
+         * Zero-based ordinal of this chunk.
+         */
+        chunkOrdinal: number;
+        /**
+         * Total number of chunks in the file.
+         */
+        numberOfChunks: number;
+        /**
+         * Optional queue position used to calculate progress for concurrent uploads.
+         */
+        positionOfChunkInQueue?: number;
+        /**
+         * Binary data for this chunk.
+         */
+        chunkBlob: Blob;
+        /**
+         * Name of the blob storage provider holding the upload session.
+         */
+        blobStorageProviderName: string;
+    };
+}
+/**
+ * Options for committing uploaded chunks into a media file.
+ *
+ * The inherited callbacks and request query fields are optional. All fields in
+ * `data` are required except `itemId`, which is used only for updates.
+ */
+export interface CommitChunksRequestOptions extends CreateRequestOptions {
+    /**
+     * Values used to construct the commit request.
+     */
+    data: {
+        /**
+         * Session identifier used for all chunks.
+         */
+        chunkedFileUploadSessionId: string;
+        /**
+         * MIME type of the complete file.
+         */
+        contentType: string;
+        /**
+         * Complete file size in bytes.
+         */
+        fileTotalSize: number;
+        /**
+         * Number of chunks uploaded for this session.
+         */
+        numberOfChunks: number;
+        /**
+         * File name.
+         */
+        name: string;
+        /**
+         * Name of the blob storage provider holding the chunks.
+         */
+        blobStorageProviderName: string;
+        /**
+         * Media properties such as `Title` and `UrlName`.
+         */
+        uploadProperties: {
+            [key: string]: string;
+        };
+        /**
+         * Existing media item identifier when replacing a file.
+         */
+        itemId?: string;
+    };
+}
+/**
+ * Options for retrieving chunk-upload settings for a media library.
+ *
+ * The inherited callbacks and request query fields are optional. `libraryId`
+ * must identify the parent library, not a folder.
+ */
+export interface GetChunkUploadInfoRequestOptions extends CreateRequestOptions {
+    /**
+     * Values used to construct the information request.
+     */
+    data: {
+        /**
+         * Parent media library in which the file will be uploaded.
+         */
+        libraryId: string;
+    };
+}
+/**
+ * Options for deleting all chunks from an upload session.
+ *
+ * The inherited callbacks and request query fields are optional. Both fields
+ * in `data` are required.
+ */
+export interface CleanUpChunksRequestOptions extends CreateRequestOptions {
+    /**
+     * Values used to construct the cleanup request.
+     */
+    data: {
+        /**
+         * Session identifier whose chunks should be deleted.
+         */
+        chunkedFileUploadSessionId: string;
+        /**
+         * Name of the blob storage provider holding the chunks.
+         */
+        blobStorageProviderName: string;
+    };
+}
+/**
+ * Server-provided settings and identifiers for a chunk upload session.
+ */
+export interface ChunkUploadInfoDTO {
+    /**
+     * Whether the provider supports chunked uploads.
+     */
+    ProviderSupportsChunkUpload: boolean;
+    /**
+     * Name of the blob storage provider to use for this session.
+     */
+    BlobStorageProviderName: string;
+    /**
+     * Identifier of the current chunk upload session.
+     */
+    ChunkedFileUploadSessionId: string;
+    /**
+     * Recommended chunk size in bytes.
+     */
+    ChunkSize: number;
+    /**
+     * Maximum number of retries for an individual chunk.
+     */
+    MaxRetryCountForChunk: number;
+    /**
+     * Maximum simultaneous chunk requests for the session.
+     */
+    MaxSimultaneousChunkUploadRequestsPerSession: number;
+}
+/**
+ * Server response returned after a chunk upload request.
+ */
+export interface ChunkUploadResult {
+    /**
+     * Whether the chunk was uploaded successfully.
+     */
+    SuccessfullyUploaded: boolean;
+    /**
+     * Identifier of the chunk upload session.
+     */
+    ChunkedFileUploadSessionId: string;
+}

package/src/chunk-upload/chunked-file-upload.utilities.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Helpers for splitting file content into chunks and normalizing upload input.
+ */
+export declare class ChunkedFileUploadUtilities {
+    /**
+     * Splits a `Blob` or base64-encoded binary string into sequential chunks.
+     *
+     * Blob input is sliced directly. A base64 string is decoded with `atob`
+     * into a Blob using `contentTypeMime` before it is sliced. Chunk ordinals
+     * start at zero; the final chunk can be smaller than `chunkSize`.
+     *
+     * @param file Blob data or a base64-encoded binary string.
+     * @param chunkSize Maximum size of each chunk in bytes.
+     * @param contentTypeMime MIME type assigned to each chunk and decoded Blob.
+     * @returns The chunks, their total count, and the original file size in bytes.
+     *
+     * @example
+     * ```ts
+     * const result = new ChunkedFileUploadUtilities().chunkFile(
+     *     base64File,
+     *     5 * 1024 * 1024,
+     *     "image/jpeg"
+     * );
+     *
+     * result.chunks.forEach(({ ordinal, content }) => {
+     *     console.log(`Chunk ${ordinal}: ${content.size} bytes`);
+     * });
+     * ```
+     */
+    chunkFile(file: Blob | string, chunkSize: number, contentTypeMime: string): ChunkFileResult;
+    /**
+     * Converts base64 binary content to a Blob before chunking.
+     *
+     * The input must contain the base64 payload expected by `atob`; a data URL
+     * prefix is not removed automatically.
+     */
+    private base64ToBlob;
+}
+/**
+ * One chunk produced by {@link ChunkedFileUploadUtilities.chunkFile}.
+ */
+export interface FileUploadChunk {
+    /** Zero-based position of this chunk in the complete file. */
+    ordinal: number;
+    /** Binary content for this chunk. */
+    content: Blob;
+}
+/**
+ * Result returned after a file is divided into upload chunks.
+ */
+export interface ChunkFileResult {
+    /** Chunks in ascending ordinal order. */
+    chunks: Array<FileUploadChunk>;
+    /** Number of chunks in `chunks`. */
+    totalChunksCount: number;
+    /** Size of the source file in bytes. */
+    fileTotalSize: number;
+}