@bytescale/sdk 1.1.0 → 1.3.0

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./generated";
-export * from "./uploads";
+export * from "./public/shared";
+export * from "./public/node";

package/dist/types/private/AuthSessionState.d.ts

@@ -0,0 +1,13 @@
+import { AuthSession } from "./model/AuthSession";
+export declare class AuthSessionState {
+    /**
+     * Intentionally global:
+     *
+     * Users frequently have problems caused by them not keeping track of *Api and *Manager instances correctly, so we
+     * make this global as in 99.9% of cases, this is what users want, and it prevents lots of common mistakes.
+     *
+     * We only set this in the browser.
+     * Never in Node.js.
+     */
+    static session: AuthSession | undefined;
+}

package/dist/types/private/ConsoleUtils.d.ts

@@ -0,0 +1,5 @@
+export declare class ConsoleUtils {
+    static error(message: string): void;
+    static warn(message: string): void;
+    private static prefix;
+}

package/dist/types/private/EnvChecker.d.ts

@@ -0,0 +1,4 @@
+export declare class EnvChecker {
+    static isNodeJs(): boolean;
+    static methodRequiresBrowser(methodName: string): Error;
+}

package/dist/types/private/Mutex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A lightweight mutex. (Other libraries contain too many features and we want to keep the size upload-js down).
+ *
+ * Characteristics:
+ * - Non-reentrant.
+ * - Unfair. (Multiple callers awaiting 'acquire' will be granted the mutex in no order.)
+ *   - When calling `safe` consecutively with no 'awaits' in-between, the current context will synchronously acquire
+ *     the mutex every time.
+ */
+export declare class Mutex {
+    private mutex;
+    private resolver;
+    safe<T>(callback: () => Promise<T>): Promise<T>;
+    private acquire;
+    private release;
+}

package/dist/types/{uploads/ChunkedStream.d.ts → private/NodeChunkedStream.d.ts}

@@ -1,5 +1,14 @@
 /// <reference types="node" />
-export declare class ChunkedStream {
+/**
+ * For Node.js streams only:
+ *
+ * Converts a stream into a stream of streams, where the next stream is requested via '.take(sizeInBytes: number): Stream'
+ *
+ * This allows the source stream to be sequentially read (in serial) as a sequence of sub-streams, for the purpose of
+ * issuing PutObject requests for a multipart upload, whereby each request requires its own stream, but where that stream
+ * needs to be a slice of the source stream.
+ */
+export declare class NodeChunkedStream {
     private readonly source;
     private buffer;
     private consumer;
@@ -21,9 +30,7 @@ export declare class ChunkedStream {
     /**
      * Only call 'take' after the previously returned stream has been fully consumed.
      */
-    take(bytes: number): Promise<NodeJS.ReadableStream>;
+    take(bytes: number): NodeJS.ReadableStream;
     private consumeFromBuffer;
     private splitBuffer;
-    private emptyStream;
-    private finishStream;
 }

package/dist/types/private/StreamUtils.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import type * as stream from "stream";
+export declare class StreamUtils {
+    static create(): stream.Readable;
+    static empty(): NodeJS.ReadableStream;
+    static fromBuffer(buffer: Buffer): NodeJS.ReadableStream;
+    static endStream(readable: stream.Readable): void;
+}

package/dist/types/private/TypeUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function assertUnreachable(x: never): never;
+export declare function isDefinedEntry<T, K extends string>(object: [K, T | undefined | null]): object is [K, T];

package/dist/types/private/UploadManagerBase.d.ts

@@ -0,0 +1,43 @@
+import { BytescaleApiClientConfig, FileDetails, UploadPart } from "../public/shared/generated";
+import { UploadManagerInterface } from "./model/UploadManagerInterface";
+import { PreUploadInfo } from "./model/PreUploadInfo";
+import { UploadSourceBlob } from "./model/UploadSourceProcessed";
+import { PutUploadPartResult } from "./model/PutUploadPartResult";
+import { AddCancellationHandler } from "./model/AddCancellationHandler";
+import { UploadManagerParams, UploadSource } from "../public/shared/CommonTypes";
+/**
+ * Methods common to UploadManagerNode and UploadManagerBrowser.
+ */
+export declare abstract class UploadManagerBase<TSource, TInit> implements UploadManagerInterface {
+    protected readonly config: BytescaleApiClientConfig;
+    protected readonly stringMimeType = "text/plain";
+    private readonly defaultMaxConcurrentUploadParts;
+    private readonly intervalMs;
+    private readonly uploadApi;
+    constructor(config: BytescaleApiClientConfig);
+    upload(request: UploadManagerParams): Promise<FileDetails>;
+    protected getBlobInfo({ value: { name, size, type } }: UploadSourceBlob): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected abstract processUploadSource(data: UploadSource): TSource;
+    protected abstract getPreUploadInfoPartial(request: UploadManagerParams, source: TSource): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected abstract preUpload(source: TSource): TInit;
+    protected abstract postUpload(init: TInit): Promise<void>;
+    protected abstract doPutUploadPart(part: UploadPart, contentLength: number, source: TSource, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
+    private onIntervalTick;
+    private makeCancellationMethods;
+    private makeProgressCallback;
+    private assertNotCancelled;
+    private isCancelled;
+    private beginUpload;
+    private uploadPart;
+    /**
+     * Returns etag for the part.
+     */
+    private putUploadPart;
+    private getUploadPart;
+    private getPreUploadInfo;
+    private mapAsync;
+}

package/dist/types/private/dtos/SetAccessTokenRequestDto.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sync with: bytescale > edge > SetAccessTokenRequestDto.ts
+ */
+export interface SetAccessTokenRequestDto {
+    accessToken: string;
+}

package/dist/types/private/dtos/SetAccessTokenResponseDto.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sync with: upload > edge > SetAccessTokenResponseDto.ts
+ */
+export interface SetAccessTokenResponseDto {
+    accessToken: string;
+    ttlSeconds: number;
+}

package/dist/types/private/model/AddCancellationHandler.d.ts

@@ -0,0 +1 @@
+export declare type AddCancellationHandler = (cancellationHandler: () => void) => void;

package/dist/types/private/model/AuthManagerInterface.d.ts

@@ -0,0 +1,44 @@
+export interface AuthManagerInterface {
+    /**
+     * Begins an authenticated Bytescale API and Bytescale CDN session.
+     *
+     * You can only call this method if 'isAuthSessionActive() === false', else an error will be returned.
+     *
+     * You can only call this method in the browser (not Node.js).
+     *
+     * You should call this method after the user has signed-in to your web app.
+     *
+     * After calling this method:
+     *
+     * 1) You must add '?auth=true' to the URL of any private file you're trying to access. This includes the URLs you use in 'src' elements in img/video elements, etc.
+     *
+     * 2) You must await the promise before attempting to perform any downloads or API operations that require authentication.
+     *
+     * The auth process works as follows:
+     *
+     * 1) After you call this method, the AuthManager will periodically fetch a JWT in plain text from the given 'authUrl'.
+     *
+     * 2) The JWT will be saved to a cookie scoped to the Bytescale CDN. This allows the user to view private files via the URL in the browser, including <img> elements on the page that reference private images, etc.
+     *
+     * 3) The JWT will also be added as a request header via 'authorization-token' to all Bytescale API requests made via this SDK. This allows the user to upload private files and perform administrative operations permitted by the JWT, such as deleting files, etc.
+     *
+     * @param authUrl The fully-qualified URL for your backend API's auth endpoint.
+     * @param authHeaders Headers to send to your backend API.
+     *                    IMPORTANT: do not call '*AuthSession' inside this callback, as this will cause a deadlock.
+     */
+    beginAuthSession: (authUrl: string, authHeaders: () => Promise<Record<string, string>>) => Promise<void>;
+    /**
+     * Ends an authenticated Bytescale API and Bytescale CDN session.
+     *
+     * This method idempotent, meaning you can call it regardless of the value of 'isAuthSessionActive()', and no error will be thrown.
+     *
+     * You can only call this method in the browser (not Node.js).
+     *
+     * You should call this method after the user has signed-out of your web app.
+     */
+    endAuthSession: () => Promise<void>;
+    /**
+     * Checks if an authenticated Bytescale API and Bytescale CDN session is active.
+     */
+    isAuthSessionActive: () => boolean;
+}

package/dist/types/private/model/AuthSession.d.ts

@@ -0,0 +1,7 @@
+export interface AuthSession {
+    accessToken: string | undefined;
+    accessTokenRefreshHandle: number | undefined;
+    authHeaders: () => Promise<Record<string, string>>;
+    authUrl: string;
+    isActive: boolean;
+}

package/dist/types/private/model/OnPartProgress.d.ts

@@ -0,0 +1 @@
+export declare type OnPartProgress = (bytesSentDelta: number) => void;

package/dist/types/private/model/PreUploadInfo.d.ts

@@ -0,0 +1,6 @@
+export interface PreUploadInfo {
+    maxConcurrentUploadParts: number;
+    mime: string | undefined;
+    originalFileName: string | undefined;
+    size: number;
+}

package/dist/types/private/model/PutUploadPartResult.d.ts

@@ -0,0 +1,4 @@
+export interface PutUploadPartResult {
+    etag: string | undefined;
+    status: number;
+}

package/dist/types/private/model/UploadManagerInterface.d.ts

@@ -0,0 +1,5 @@
+import { UploadManagerParams } from "../../public/shared/CommonTypes";
+import { FileDetails } from "../../public/shared/generated";
+export interface UploadManagerInterface {
+    upload: (request: UploadManagerParams) => Promise<FileDetails>;
+}

package/dist/types/private/model/UploadSourceProcessed.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { BlobLike } from "../../public/shared/CommonTypes";
+import { NodeChunkedStream } from "../NodeChunkedStream";
+export interface UploadSourceBlob {
+    type: "Blob";
+    value: BlobLike;
+}
+export interface UploadSourceBuffer {
+    type: "Buffer";
+    value: Buffer;
+}
+export interface UploadSourceStream {
+    type: "Stream";
+    value: NodeChunkedStream;
+}
+export declare type UploadSourceProcessedIsomorphic = UploadSourceBlob;
+export declare type UploadSourceProcessedBrowser = UploadSourceProcessedIsomorphic;
+export declare type UploadSourceProcessedNode = UploadSourceStream | UploadSourceBuffer | UploadSourceProcessedIsomorphic;

package/dist/types/public/browser/AuthManagerBrowser.d.ts

@@ -0,0 +1,20 @@
+import { AuthManagerInterface } from "../../private/model/AuthManagerInterface";
+import { BaseAPI, BytescaleApiClientConfig } from "../shared/generated";
+export declare class AuthManager extends BaseAPI implements AuthManagerInterface {
+    private readonly accessTokenUrl;
+    private readonly authSessionMutex;
+    private readonly contentType;
+    private readonly contentTypeJson;
+    private readonly contentTypeText;
+    private readonly minJwtTtlSeconds;
+    private readonly retryAuthAfterErrorSeconds;
+    private readonly refreshBeforeExpirySeconds;
+    constructor(config: BytescaleApiClientConfig);
+    isAuthSessionActive(): boolean;
+    beginAuthSession(authUrl: string, authHeaders: () => Promise<Record<string, string>>): Promise<void>;
+    endAuthSession(): Promise<void>;
+    private refreshAccessToken;
+    private deleteAccessToken;
+    private setAccessToken;
+    private getAccessToken;
+}

package/dist/types/public/browser/UploadManagerBrowser.d.ts

@@ -0,0 +1,17 @@
+import { UploadManagerBase } from "../../private/UploadManagerBase";
+import { UploadSourceProcessedBrowser } from "../../private/model/UploadSourceProcessed";
+import { PreUploadInfo } from "../../private/model/PreUploadInfo";
+import { UploadPart } from "../shared/generated";
+import { PutUploadPartResult } from "../../private/model/PutUploadPartResult";
+import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
+import { UploadManagerParams, UploadSource } from "../shared/CommonTypes";
+export declare class UploadManager extends UploadManagerBase<UploadSourceProcessedBrowser, undefined> {
+    protected processUploadSource(data: UploadSource): UploadSourceProcessedBrowser;
+    protected getPreUploadInfoPartial(_request: UploadManagerParams, data: UploadSourceProcessedBrowser): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected preUpload(_source: UploadSourceProcessedBrowser): undefined;
+    protected postUpload(_init: undefined): Promise<void>;
+    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedBrowser, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<PutUploadPartResult>;
+    private getRequestBody;
+}

package/dist/types/public/browser/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UploadManagerBrowser";
+export * from "./AuthManagerBrowser";

package/dist/types/public/node/AuthManagerNode.d.ts

@@ -0,0 +1,6 @@
+import { AuthManagerInterface } from "../../private/model/AuthManagerInterface";
+export declare class AuthManager implements AuthManagerInterface {
+    beginAuthSession(_authUrl: string, _authHeaders: () => Promise<Record<string, string>>): Promise<void>;
+    endAuthSession(): Promise<void>;
+    isAuthSessionActive(): boolean;
+}

package/dist/types/public/node/UploadManagerNode.d.ts

@@ -0,0 +1,26 @@
+import { UploadManagerBase } from "../../private/UploadManagerBase";
+import { UploadSourceProcessedNode } from "../../private/model/UploadSourceProcessed";
+import { NodeChunkedStream } from "../../private/NodeChunkedStream";
+import { PreUploadInfo } from "../../private/model/PreUploadInfo";
+import { UploadPart } from "../shared/generated";
+import { AddCancellationHandler } from "../../private/model/AddCancellationHandler";
+import { UploadManagerParams, UploadSource } from "../shared/CommonTypes";
+declare type UploadManagerNodeInit = undefined | {
+    chunkedStream: NodeChunkedStream;
+    chunkedStreamPromise: Promise<void>;
+};
+export declare class UploadManager extends UploadManagerBase<UploadSourceProcessedNode, UploadManagerNodeInit> {
+    protected processUploadSource(data: UploadSource): UploadSourceProcessedNode;
+    protected getPreUploadInfoPartial(request: UploadManagerParams, data: UploadSourceProcessedNode): Partial<PreUploadInfo> & {
+        size: number;
+    };
+    protected preUpload(source: UploadSourceProcessedNode): UploadManagerNodeInit;
+    protected postUpload(init: UploadManagerNodeInit): Promise<void>;
+    protected doPutUploadPart(part: UploadPart, contentLength: number, source: UploadSourceProcessedNode, onProgress: (bytesSentDelta: number) => void, addCancellationHandler: AddCancellationHandler): Promise<{
+        etag: string | undefined;
+        status: number;
+    }>;
+    private coerceRequestBody;
+    private sliceDataForRequest;
+}
+export {};

package/dist/types/public/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UploadManagerNode";
+export * from "./AuthManagerNode";

package/dist/types/{uploads/UploadModel.d.ts → public/shared/CommonTypes.d.ts}

@@ -1,12 +1,9 @@
 /// <reference types="node" />
+import { BeginMultipartUploadRequest } from "./generated";
 /**
- * Supported implementations:
- * - Node.js 'buffer.Blob', e.g. 'new buffer.Blob([JSON.stringify({someValue: 42})], {type: "application/json"})'
- * - Browser 'Blob', e.g. 'new Blob([JSON.stringify({someValue: 42})], {type: "application/json"})'
- * - Browser 'File', e.g. from a <input type="file" onchange="...">
+ * Workaround for tsc aliases, where we cannot export implementation-less modules in our dists.
  */
-import { BeginMultipartUploadRequest } from "../generated";
-import { ChunkedStream } from "./ChunkedStream";
+export declare const CommonTypesNoOp = false;
 export interface BlobLike {
     readonly name?: string;
     readonly size: number;
@@ -16,10 +13,10 @@ export interface BlobLike {
 export interface CancellationToken {
     isCancelled: boolean;
 }
-export declare class CancelledError extends Error {
-    msg?: string | undefined;
-    name: "CancelledError";
-    constructor(msg?: string | undefined);
+export interface UploadProgress {
+    bytesSent: number;
+    bytesTotal: number;
+    progress: number;
 }
 export declare type UploadSource = NodeJS.ReadableStream | BlobLike | Buffer | string;
 export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "size" | "protocol"> {
@@ -27,9 +24,9 @@ export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "
     cancellationToken?: CancellationToken;
     data: UploadSource;
     maxConcurrentUploadParts?: number;
+    onProgress?: (status: UploadProgress) => void;
     /**
      * Only required if 'data' is a 'ReadableStream'.
      */
     size?: number;
 }
-export declare type UploadSourceProcessed = ChunkedStream | BlobLike | Buffer;

package/dist/types/public/shared/UrlBuilder.d.ts

@@ -0,0 +1,28 @@
+import { UrlBuilderConfig, UrlBuilderParams } from "./UrlBuilderTypes";
+export declare class UrlBuilder {
+    private readonly cdnUrl;
+    constructor(config?: UrlBuilderConfig);
+    /**
+     * Builds a URL to either a raw file or a transformed file.
+     *
+     * Example 1) Raw file:
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg" })
+     *
+     * Example 2) Image resized to 500x500:
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", transformation: { type: "image", params: { w: 500, h: 500, fit: "crop" } } })
+     *
+     * Example 3) Image resized to 500x500, which is privately accessible (i.e. requires 'AuthManager.beginAuthSession' before it can be accessed):
+     *
+     *   new UrlBuilder().url({ accountId: "1234abc", filePath: "/example.jpg", transformation: { type: "image", params: { w: 500, h: 500, fit: "crop" } }, auth: true })
+     */
+    url(params: UrlBuilderParams): string;
+    private raw;
+    private transformation;
+    private getBaseUrl;
+    private getCommonQueryParams;
+    private makeQueryParams;
+    private getTransformationParams;
+    private addQueryParams;
+}

package/dist/types/public/shared/UrlBuilderTypes.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Workaround for tsc aliases, where we cannot export implementation-less modules in our dists.
+ */
+export declare const UrlBuilderTypesNoOp = false;
+export declare type ParameterGroup = Record<string, string | number | boolean | undefined | null>;
+export declare type KeyValuePair = [string, string];
+export interface UrlBuilderConfig {
+    /**
+     * The base URL of the Bytescale CDN.
+     */
+    cdnUrl?: string;
+}
+export interface UrlBuilderParams {
+    /**
+     * The account that manages the file.
+     */
+    accountId: string;
+    /**
+     * The file to download.
+     *
+     * Must begin with: "/"
+     */
+    filePath: string;
+    /**
+     * Optional parameters to control how the URL is constructed.
+     */
+    options?: UrlBuilderOptions;
+}
+export interface UrlBuilderOptions {
+    /**
+     * Set to 'true' to download a private file. Requires an active auth session. See AuthManager.beginAuthSession.
+     *
+     * Set to 'false' or omit when downloading publicly-accessible files.
+     *
+     * Default: false
+     */
+    auth?: boolean;
+    /**
+     * Specifies whether to use caching for this request, or to always re-request the file.
+     *
+     * For file transformations, setting 'true' will cause the file to be re-processed on every request.
+     *
+     * Default: false
+     */
+    cache?: boolean;
+    /**
+     * Specifies the maximum amount of time, in seconds, the file will be cached on the user's device and in the Bytescale CDN's edge cache.
+     *
+     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
+     */
+    cacheTtl?: number;
+    /**
+     * Forces the browser to display a download prompt for the file, instead of displaying the file in the browser.
+     *
+     * When set to true, the Bytescale CDN will add a 'content-disposition: attachment' header to the HTTP response.
+     *
+     * Default: false
+     */
+    forceDownloadPrompt?: boolean;
+    transformation?: UrlBuilderParamsTransformation;
+    /**
+     * Downloads the latest version of your file (if you have overwritten it) when added to the URL with a unique value.
+     *
+     * The value of the version parameter can be anything, e.g. an incremental number, a timestamp, etc.
+     *
+     * You only need to provide and update this value if/when you overwrite your file.
+     */
+    version?: string;
+}
+export declare type UrlBuilderParamsTransformation = UrlBuilderParamsTransformationPreset | UrlBuilderParamsImageTransformation | UrlBuilderParamsVideoTransformation | UrlBuilderParamsAudioTransformation | UrlBuilderParamsArchiveTransformation;
+export interface UrlBuilderParamsTransformationOptions {
+    /**
+     * The transformation artifact to download.
+     *
+     * Some transformations produce multiple files. The 'artifact' parameter is used to select which file to download.
+     *
+     * Must begin with: "/"
+     *
+     * Default: "/"
+     */
+    artifact?: string;
+    /**
+     * Specifies whether to permanently cache the transformed result in the Bytescale CDN.
+     *
+     * Permanently cached files can be deleted via a manual action in the Bytescale Dashboard.
+     *
+     * When cache=false this parameter is automatically set to false.
+     *
+     * When cachePermanently="auto" the permanent cache will only be used for files that take more than 1000ms to process.
+     *
+     * When the permanent cache is used, approximately 200ms of latency is added to the initial request. Thereafter, files will be served from the Bytescale CDN's edge cache or permanent cache, so will have minimal latency.
+     *
+     * Default: Please refer to your account's default cache settings in the Bytescale Dashboard.
+     */
+    cachePermanently?: "auto" | boolean;
+    /**
+     * Set to true to return transformed files over 6MB in the initial HTTP response.
+     *
+     * By default, transformations that produce files larger than 6MB require a subsequent HTTP request to return the result: the initial HTTP request will process the file and return a JSON result instructing the requester the transformation has been performed. All subsequent requests will return the transformed file. Enable this flag to ensure the transformed file is always returned in the initial response.
+     *
+     * Recommendation: set large=true only if you require transformation results over 6MB. A small amount of latency is incurred on edge cache misses when this flag is enabled. In general, we recommend adjusting your transformation parameters to keep files below this size, instead of enabling this flag.
+     *
+     * Default: false
+     */
+    large?: boolean;
+}
+export interface UrlBuilderParamsTransformationApiBase<T> {
+    /**
+     * Use the "params" field to pass parameters to the File Processing API.
+     *
+     * Use the "type" field to specify which File Processing API to use:
+     *
+     * - https://www.bytescale.com/docs/image-processing-api
+     * - https://www.bytescale.com/docs/video-processing-api
+     * - https://www.bytescale.com/docs/audio-processing-api
+     * - https://www.bytescale.com/docs/archive-processing-api
+     *
+     * To repeat a parameter (e.g. when adding multiple text layers to an image), use an array instead of an object, e.g.
+     *
+     *    [ { text: "hello" }, { text: "world" } ]
+     *
+     * Order is sensitive both within and across parameter groups for certain transformation operations, please consult
+     * the documentation for the File Processing API you are using (see links above).
+     */
+    params?: (T & UrlBuilderParamsTransformationOptions) | Array<T & UrlBuilderParamsTransformationOptions>;
+}
+export interface UrlBuilderParamsTransformationPreset {
+    params?: UrlBuilderParamsTransformationOptions;
+    /**
+     * The name of the transformation preset, as displayed in the Bytescale Dashboard.
+     *
+     * To specify transformation parameters on-the-fly, set "type" to a File Processing API (e.g. "image", "video", "audio"), and then use the "params" field to pass parameters to the File Processing API.
+     */
+    preset: string;
+    /**
+     * Use a transformation preset that was created in the Bytescale Dashboard.
+     *
+     * To specify transformation parameters on-the-fly, set "type" to a File Processing API (e.g. "image", "video", "audio"), and then use the "params" field to pass parameters to the File Processing API.
+     */
+    type: "preset";
+}
+export interface UrlBuilderParamsImageTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
+    /**
+     * Set to "image" to use Bytescale's Image Processing API:
+     *
+     * https://www.bytescale.com/docs/image-processing-api
+     */
+    type: "image";
+}
+export interface UrlBuilderParamsVideoTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
+    /**
+     * Set to "video" to use Bytescale's Video Processing API:
+     *
+     * https://www.bytescale.com/docs/video-processing-api
+     */
+    type: "video";
+}
+export interface UrlBuilderParamsAudioTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
+    /**
+     * Set to "audio" to use Bytescale's Audio Processing API:
+     *
+     * https://www.bytescale.com/docs/audio-processing-api
+     */
+    type: "audio";
+}
+export interface UrlBuilderParamsArchiveTransformation extends UrlBuilderParamsTransformationApiBase<ParameterGroup> {
+    /**
+     * Set to "archive" to use Bytescale's Archive Processing API:
+     *
+     * https://www.bytescale.com/docs/archive-processing-api
+     */
+    type: "archive";
+}