@bytescale/sdk 1.2.0 → 1.3.0

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+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/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/{uploads/private → private}/UploadManagerBase.d.ts

@@ -1,10 +1,10 @@
-import { BytescaleApiClientConfig, FileDetails, UploadPart } from "../../generated";
-import { UploadManagerParams, UploadSource } from "../public/shared";
+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.
  */

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/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/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/{uploads/private → private}/model/UploadSourceProcessed.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { BlobLike } from "../../public/shared/Model";
+import { BlobLike } from "../../public/shared/CommonTypes";
 import { NodeChunkedStream } from "../NodeChunkedStream";
 export interface UploadSourceBlob {
     type: "Blob";

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/{uploads/public → public}/browser/UploadManagerBrowser.d.ts

@@ -1,10 +1,10 @@
 import { UploadManagerBase } from "../../private/UploadManagerBase";
 import { UploadSourceProcessedBrowser } from "../../private/model/UploadSourceProcessed";
-import { UploadManagerParams, UploadSource } from "../shared";
 import { PreUploadInfo } from "../../private/model/PreUploadInfo";
-import { UploadPart } from "../../../generated";
+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> & {

package/dist/types/{uploads/public → public}/browser/index.d.ts

@@ -1 +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/{uploads/public → public}/node/UploadManagerNode.d.ts

@@ -1,10 +1,10 @@
 import { UploadManagerBase } from "../../private/UploadManagerBase";
 import { UploadSourceProcessedNode } from "../../private/model/UploadSourceProcessed";
 import { NodeChunkedStream } from "../../private/NodeChunkedStream";
-import { UploadManagerParams, UploadSource } from "../shared";
 import { PreUploadInfo } from "../../private/model/PreUploadInfo";
-import { UploadPart } from "../../../generated";
+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>;

package/dist/types/{uploads/public → public}/node/index.d.ts

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

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

@@ -1,11 +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";
+export declare const CommonTypesNoOp = false;
 export interface BlobLike {
     readonly name?: string;
     readonly size: number;
@@ -20,10 +18,6 @@ export interface UploadProgress {
     bytesTotal: number;
     progress: number;
 }
-export declare class CancelledError extends Error {
-    name: "CancelledError";
-    constructor();
-}
 export declare type UploadSource = NodeJS.ReadableStream | BlobLike | Buffer | string;
 export interface UploadManagerParams extends Omit<BeginMultipartUploadRequest, "size" | "protocol"> {
     accountId: string;

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";
+}

package/dist/types/{generated → public/shared/generated}/runtime.d.ts

@@ -10,22 +10,61 @@ import { ErrorResponse } from "./models";
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
-export declare const BASE_PATH: string;
 export interface BytescaleApiClientConfig {
+    /**
+     * Required for Node.js: you must provide an instance of requires("node-fetch")
+     *
+     * Not required for the browser.
+     */
     fetchApi?: FetchAPI;
-    apiKey?: string | ((name: string) => string);
+    /**
+     * Required for all environments. Must begin with "public_" or "secret_".
+     *
+     * Please note: if you require JWT-based auth, you must provide an API key to this field, and then call 'AuthManager.beginAuthSession' to start a JWT-based auth session. The JWT's permissions will be merged with the API key's permissions, with precedence given to the JWT.
+     */
+    apiKey: string;
+    /**
+     * The base URL of the Bytescale API.
+     */
+    apiUrl?: string;
+    /**
+     * The base URL of the Bytescale CDN.
+     */
+    cdnUrl?: string;
+    /**
+     * Headers to include in all API requests.
+     *
+     * These headers take precedence over any headers automatically added by the SDK (e.g. "Authorization", "Content-Type", etc.).
+     */
     headers?: () => Promise<HTTPHeaders>;
 }
+export declare class BytescaleApiClientConfigResolver {
+    static defaultApiUrl: string;
+    static defaultCdnUrl: string;
+    static getApiUrl(config: BytescaleApiClientConfig): string;
+    static getCdnUrl(config: BytescaleApiClientConfig): string;
+    static getFetchApi(config: BytescaleApiClientConfig): FetchAPI;
+}
 /**
  * This is the base class for all generated API classes.
  */
 export declare class BaseAPI {
     protected readonly config: BytescaleApiClientConfig;
+    protected static readonly specialApiKeys: string[];
+    protected static readonly specialApiKeyAccountId = "W142hJk";
+    protected static readonly accountIdLength = 7;
     constructor(config: BytescaleApiClientConfig);
-    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, operationBasePathOverride: string | undefined): Promise<Response>;
+    protected request(context: RequestOpts, initOverrides: RequestInit | InitOverrideFunction | undefined, baseUrlOverride: string | undefined): Promise<Response>;
+    /**
+     * Returns a successful response (2**) else throws an error.
+     */
+    protected doFetch(url: string, init: RequestInit, isBytescaleApi: boolean): Promise<Response>;
     protected encodeParam(paramName: string, paramValue: string): string;
     private createFetchParams;
-    private fetchApi;
+}
+export declare class CancelledError extends Error {
+    name: "CancelledError";
+    constructor();
 }
 export declare class BytescaleApiError extends Error {
     name: "BytescaleApiError";
@@ -48,15 +87,10 @@ export declare type HTTPRequestInit = {
     method: HTTPMethod;
     body?: HTTPBody;
 };
-export declare type ModelPropertyNaming = "camelCase" | "snake_case" | "PascalCase" | "original";
 export declare type InitOverrideFunction = (requestContext: {
     init: HTTPRequestInit;
     context: RequestOpts;
 }) => Promise<RequestInit>;
-export interface FetchParams {
-    url: string;
-    init: RequestInit;
-}
 export interface RequestOpts {
     path: string;
     method: HTTPMethod;
@@ -69,13 +103,9 @@ export interface ApiResponse<T> {
     raw: Response;
     value(): Promise<T>;
 }
-export interface ResponseTransformer<T> {
-    (json: any): T;
-}
 export declare class JSONApiResponse<T> {
     raw: Response;
-    private transformer;
-    constructor(raw: Response, transformer?: ResponseTransformer<T>);
+    constructor(raw: Response);
     value(): Promise<T>;
 }
 export declare class VoidApiResponse {

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

@@ -0,0 +1,4 @@
+export * from "./generated";
+export * from "./CommonTypes";
+export * from "./UrlBuilder";
+export * from "./UrlBuilderTypes";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytescale/sdk",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Bytescale JavaScript SDK",
   "author": "Bytescale <hello@bytescale.com> (https://www.bytescale.com)",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
     "typecheck": "tsc --noEmit",
     "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --runInBand --silent=false --verbose=false",
-    "prepack": "npm run clean && webpack && tsc-alias",
+    "prepack": "npm run clean && webpack && tsc-alias && rm dist/types/index.browser.d.ts && mv dist/types/index.node.d.ts dist/types/index.d.ts",
     "postpack": "[ ! -f bytescale-sdk-*.tgz ] || mv bytescale-sdk-*.tgz bytescale-sdk.tgz",
     "prepare": "husky install",
     "prepack:cdn": "npm run clean && webpack --config webpack.config.cdn.js && find dist -name \"*.ts\" -type f -delete && for f in dist/*.js; do cp -- \"$f\" \"${f%.js}\"; done",

package/tests/ChunkedStream.test.ts

@@ -1,4 +1,4 @@
-import { NodeChunkedStream } from "../src/uploads/private/NodeChunkedStream";
+import { NodeChunkedStream } from "../src/private/NodeChunkedStream";
 import { createRandomStreamFactory } from "./utils/RandomStream";
 import { streamToBuffer } from "./utils/StreamToBuffer";