@unofficialbox/box-open-sdk 0.1.2 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyle @ Unofficial Box
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,7 +5,7 @@
 
 [![npm](https://img.shields.io/npm/v/@unofficialbox/box-open-sdk.svg)](https://www.npmjs.com/package/@unofficialbox/box-open-sdk)
 
-A **community, unofficial** Box API client for TypeScript — fully typed models
+An **open source, community-built** Box API client for TypeScript — fully typed models
 for the whole Box surface, one manager per API area behind a single `Client`,
 and a `fetch`-based runtime with retry, backoff, and token refresh. Ships as a
 **dual ESM/CJS** package with bundled `.d.ts` declarations; no runtime
@@ -22,20 +22,56 @@ npm install @unofficialbox/box-open-sdk
 
 ## Quickstart
 
+Authenticate, look up the current user, create a folder, upload a file, extract
+its fields with Box AI, tag it with metadata, and query for it — end to end:
+
 ```ts
-import { Client, runtime } from '@unofficialbox/box-open-sdk';
+import { Client, auth } from '@unofficialbox/box-open-sdk';
 
-// Developer token for a quick start; CCG, OAuth, and JWT are also supported.
-const client = new Client(runtime.developerToken('DEVELOPER_TOKEN'));
+// Client Credentials Grant (server-to-server); developer token, OAuth, and JWT
+// also live in the `auth` namespace.
+const client = new Client(auth.clientCredentials({
+  clientId: 'CLIENT_ID',
+  clientSecret: 'CLIENT_SECRET',
+  enterpriseId: 'ENTERPRISE_ID',
+}));
 
-// Every API area is a typed manager on the client.
+// The current user.
 const me = await client.users.getMe();
-console.log(me);
-
-// List endpoints are async iterators — paging is automatic.
-for await (const user of client.users.list()) {
-  console.log(user.id);
-}
+console.log(`authenticated as ${me.id}`);
+
+// Create a folder at the account root ("0").
+const folder = await client.folders.create({
+  name: 'Invoices',
+  parent: { id: '0' },
+});
+
+// Upload a file into it.
+const uploaded = await client.uploads.uploadFile({
+  attributes: { name: 'invoice.pdf', parent: { id: folder.id } },
+  file: new Blob(['<file bytes>']),
+});
+const fileId = uploaded.entries![0].id;
+
+// Extract fields from the file with Box AI.
+const answer = await client.ai.extract({
+  prompt: 'Extract the invoice number and total amount.',
+  items: [{ id: fileId, type: 'file' }],
+});
+console.log(answer);
+
+// Attach that metadata to the file (an enterprise template).
+await client.fileMetadata.createFileMetadata(fileId, 'enterprise', 'invoiceData', {
+  invoiceNumber: 'INV-0042',
+  total: 1250,
+});
+
+// Query for files carrying that metadata.
+const results = await client.search.queryByMetadata({
+  from: 'enterprise_0.invoiceData',
+  ancestor_folder_id: folder.id,
+});
+console.log(results);
 ```
 
 ## Authentication

package/dist/cjs/chunked_upload.js

@@ -0,0 +1,108 @@
+"use strict";
+// Code generated by box-gantry. DO NOT EDIT.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkedUpload = void 0;
+/**
+ * ChunkedUpload orchestrates a Box chunked (multipart) upload over a Client: it
+ * creates an upload session, uploads the content's parts with bounded
+ * concurrency, and commits — for a new file (upload) or a new version of an
+ * existing file (uploadVersion). Box requires chunked upload for files at or
+ * above its minimum session size; smaller files use the single-shot endpoints.
+ */
+class ChunkedUpload {
+    client;
+    /** Bounds parts in flight, capping peak memory. */
+    maxConcurrent = 4;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Upload content as a new file named fileName into folderId. */
+    async upload(content, fileName, folderId) {
+        const session = await this.client.chunkedUploads.createFileUploadSession({
+            folder_id: folderId,
+            file_size: content.length,
+            file_name: fileName,
+        });
+        return this.finish(session, content);
+    }
+    /** Upload content as a new version of the existing file fileId. */
+    async uploadVersion(content, fileName, fileId) {
+        const session = await this.client.chunkedUploads.createFileVersionUploadSession(fileId, {
+            file_size: content.length,
+            file_name: fileName,
+        });
+        return this.finish(session, content);
+    }
+    async finish(session, content) {
+        if (session.id === undefined) {
+            throw new Error('gantry: upload session returned no id');
+        }
+        if (session.part_size === undefined || session.part_size <= 0) {
+            throw new Error('gantry: upload session returned a non-positive part_size');
+        }
+        const id = session.id;
+        const partSize = session.part_size;
+        const total = content.length;
+        const offsets = [];
+        for (let off = 0; off < total; off += partSize) {
+            offsets.push(off);
+        }
+        const parts = new Array(offsets.length);
+        // A bounded worker pool: each of maxConcurrent workers claims the next
+        // offset (the `next++` read is atomic between awaits on a single thread).
+        // Once any part fails, `failed` stops the others from starting new parts,
+        // so a failure early in a large upload doesn't push every remaining part.
+        let next = 0;
+        let failed = false;
+        const worker = async () => {
+            for (;;) {
+                if (failed) {
+                    return;
+                }
+                const i = next++;
+                if (i >= offsets.length) {
+                    return;
+                }
+                const start = offsets[i];
+                const end = Math.min(start + partSize, total);
+                try {
+                    parts[i] = await this.uploadPart(id, content, start, end, total);
+                }
+                catch (err) {
+                    failed = true;
+                    throw err;
+                }
+            }
+        };
+        const workerCount = Math.min(this.maxConcurrent, offsets.length);
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        const digest = 'sha=' + (await sha1Base64(content));
+        return this.client.chunkedUploads.commitFileUploadSession(id, digest, { parts });
+    }
+    async uploadPart(id, content, start, end, total) {
+        const slice = content.subarray(start, end);
+        const digest = 'sha=' + (await sha1Base64(slice));
+        const contentRange = `bytes ${start}-${end - 1}/${total}`;
+        // The `as BlobPart` cast bridges the `Uint8Array<ArrayBufferLike>` vs
+        // `BufferSource` (ArrayBuffer-only) generic gap in the DOM lib, exactly as
+        // the runtime casts its `fetch` body; a plain `Uint8Array` is a valid part.
+        const uploaded = await this.client.chunkedUploads.updateFileUploadSession(id, digest, contentRange, new Blob([slice]));
+        if (uploaded.part === undefined) {
+            throw new Error('gantry: upload part returned no part');
+        }
+        return uploaded.part;
+    }
+}
+exports.ChunkedUpload = ChunkedUpload;
+/** Base64 of the SHA-1 of data — the Box `Digest: sha=…` header value. Uses Web
+ *  Crypto (browser and Node 18+), so it adds no dependency. */
+async function sha1Base64(data) {
+    // `as BufferSource` bridges the `Uint8Array<ArrayBufferLike>` vs ArrayBuffer-only
+    // generic gap in the DOM lib (as the runtime does for its `fetch` body).
+    const digest = new Uint8Array(await crypto.subtle.digest('SHA-1', data));
+    let binary = '';
+    for (const byte of digest) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}

package/dist/cjs/index.js

@@ -34,10 +34,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildinfo = exports.runtime = exports.managers = exports.models = exports.Client = void 0;
+exports.ChunkedUpload = exports.buildinfo = exports.auth = exports.runtime = exports.managers = exports.models = exports.Client = void 0;
 var client_js_1 = require("./client.js");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });
 exports.models = __importStar(require("./models/index.js"));
 exports.managers = __importStar(require("./managers/index.js"));
 exports.runtime = __importStar(require("./runtime.js"));
+exports.auth = __importStar(require("./auth.js"));
 exports.buildinfo = __importStar(require("./buildinfo.js"));
+var chunked_upload_js_1 = require("./chunked_upload.js");
+Object.defineProperty(exports, "ChunkedUpload", { enumerable: true, get: function () { return chunked_upload_js_1.ChunkedUpload; } });

package/dist/cjs/managers/chunked_uploads.js

@@ -43,7 +43,7 @@ class ChunkedUploadsManager {
     constructor(session) {
         this.session = session;
     }
-    async createFileUploadSessions(body) {
+    async createFileUploadSession(body) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += "/upload_sessions";
@@ -54,7 +54,7 @@ class ChunkedUploadsManager {
         const data = runtime.responseBytes(resp);
         return JSON.parse(new TextDecoder().decode(data));
     }
-    async createFileByIdUploadSessions(fileId, body) {
+    async createFileVersionUploadSession(fileId, body) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += '/' + (0, internal_js_1.pathEscape)(fileId);
@@ -84,8 +84,8 @@ class ChunkedUploadsManager {
         let req = this.session.newRequest("PUT", url);
         req = runtime.withHeader(req, "digest", digest);
         req = runtime.withHeader(req, "content-range", contentRange);
-        void body;
-        req = runtime.withStreamBody(req, runtime.Stream.empty(), 'application/octet-stream');
+        const fileBytes = new Uint8Array(await body.arrayBuffer());
+        req = runtime.withStreamBody(req, new runtime.Stream(fileBytes), 'application/octet-stream');
         const resp = await this.session.fetch(req);
         const data = runtime.responseBytes(resp);
         return JSON.parse(new TextDecoder().decode(data));

package/dist/cjs/managers/search.js

@@ -43,7 +43,7 @@ class SearchManager {
     constructor(session) {
         this.session = session;
     }
-    async createMetadataQueryExecuteRead(body) {
+    async queryByMetadata(body) {
         let url = this.session.baseUrl("api");
         url += "/metadata_queries";
         url += "/execute_read";

package/dist/cjs/managers/transfer.js

@@ -43,7 +43,7 @@ class TransferManager {
     constructor(session) {
         this.session = session;
     }
-    async updateUserFolder0(userId, body, opts) {
+    async transferFolders(userId, body, opts) {
         let url = this.session.baseUrl("api");
         url += "/users";
         url += '/' + (0, internal_js_1.pathEscape)(userId);

package/dist/cjs/managers/uploads.js

@@ -43,7 +43,7 @@ class UploadsManager {
     constructor(session) {
         this.session = session;
     }
-    async createFileContent(fileId, body, opts) {
+    async uploadFileVersion(fileId, body, opts) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += '/' + (0, internal_js_1.pathEscape)(fileId);
@@ -65,7 +65,7 @@ class UploadsManager {
         const data = runtime.responseBytes(resp);
         return JSON.parse(new TextDecoder().decode(data));
     }
-    async createFileContent2(body, opts) {
+    async uploadFile(body, opts) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += "/content";

package/dist/esm/chunked_upload.js

@@ -0,0 +1,104 @@
+// Code generated by box-gantry. DO NOT EDIT.
+/**
+ * ChunkedUpload orchestrates a Box chunked (multipart) upload over a Client: it
+ * creates an upload session, uploads the content's parts with bounded
+ * concurrency, and commits — for a new file (upload) or a new version of an
+ * existing file (uploadVersion). Box requires chunked upload for files at or
+ * above its minimum session size; smaller files use the single-shot endpoints.
+ */
+export class ChunkedUpload {
+    client;
+    /** Bounds parts in flight, capping peak memory. */
+    maxConcurrent = 4;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Upload content as a new file named fileName into folderId. */
+    async upload(content, fileName, folderId) {
+        const session = await this.client.chunkedUploads.createFileUploadSession({
+            folder_id: folderId,
+            file_size: content.length,
+            file_name: fileName,
+        });
+        return this.finish(session, content);
+    }
+    /** Upload content as a new version of the existing file fileId. */
+    async uploadVersion(content, fileName, fileId) {
+        const session = await this.client.chunkedUploads.createFileVersionUploadSession(fileId, {
+            file_size: content.length,
+            file_name: fileName,
+        });
+        return this.finish(session, content);
+    }
+    async finish(session, content) {
+        if (session.id === undefined) {
+            throw new Error('gantry: upload session returned no id');
+        }
+        if (session.part_size === undefined || session.part_size <= 0) {
+            throw new Error('gantry: upload session returned a non-positive part_size');
+        }
+        const id = session.id;
+        const partSize = session.part_size;
+        const total = content.length;
+        const offsets = [];
+        for (let off = 0; off < total; off += partSize) {
+            offsets.push(off);
+        }
+        const parts = new Array(offsets.length);
+        // A bounded worker pool: each of maxConcurrent workers claims the next
+        // offset (the `next++` read is atomic between awaits on a single thread).
+        // Once any part fails, `failed` stops the others from starting new parts,
+        // so a failure early in a large upload doesn't push every remaining part.
+        let next = 0;
+        let failed = false;
+        const worker = async () => {
+            for (;;) {
+                if (failed) {
+                    return;
+                }
+                const i = next++;
+                if (i >= offsets.length) {
+                    return;
+                }
+                const start = offsets[i];
+                const end = Math.min(start + partSize, total);
+                try {
+                    parts[i] = await this.uploadPart(id, content, start, end, total);
+                }
+                catch (err) {
+                    failed = true;
+                    throw err;
+                }
+            }
+        };
+        const workerCount = Math.min(this.maxConcurrent, offsets.length);
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        const digest = 'sha=' + (await sha1Base64(content));
+        return this.client.chunkedUploads.commitFileUploadSession(id, digest, { parts });
+    }
+    async uploadPart(id, content, start, end, total) {
+        const slice = content.subarray(start, end);
+        const digest = 'sha=' + (await sha1Base64(slice));
+        const contentRange = `bytes ${start}-${end - 1}/${total}`;
+        // The `as BlobPart` cast bridges the `Uint8Array<ArrayBufferLike>` vs
+        // `BufferSource` (ArrayBuffer-only) generic gap in the DOM lib, exactly as
+        // the runtime casts its `fetch` body; a plain `Uint8Array` is a valid part.
+        const uploaded = await this.client.chunkedUploads.updateFileUploadSession(id, digest, contentRange, new Blob([slice]));
+        if (uploaded.part === undefined) {
+            throw new Error('gantry: upload part returned no part');
+        }
+        return uploaded.part;
+    }
+}
+/** Base64 of the SHA-1 of data — the Box `Digest: sha=…` header value. Uses Web
+ *  Crypto (browser and Node 18+), so it adds no dependency. */
+async function sha1Base64(data) {
+    // `as BufferSource` bridges the `Uint8Array<ArrayBufferLike>` vs ArrayBuffer-only
+    // generic gap in the DOM lib (as the runtime does for its `fetch` body).
+    const digest = new Uint8Array(await crypto.subtle.digest('SHA-1', data));
+    let binary = '';
+    for (const byte of digest) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+}

package/dist/esm/index.js

@@ -3,4 +3,6 @@ export { Client } from './client.js';
 export * as models from './models/index.js';
 export * as managers from './managers/index.js';
 export * as runtime from './runtime.js';
+export * as auth from './auth.js';
 export * as buildinfo from './buildinfo.js';
+export { ChunkedUpload } from './chunked_upload.js';

package/dist/esm/managers/chunked_uploads.js

@@ -7,7 +7,7 @@ export class ChunkedUploadsManager {
     constructor(session) {
         this.session = session;
     }
-    async createFileUploadSessions(body) {
+    async createFileUploadSession(body) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += "/upload_sessions";
@@ -18,7 +18,7 @@ export class ChunkedUploadsManager {
         const data = runtime.responseBytes(resp);
         return JSON.parse(new TextDecoder().decode(data));
     }
-    async createFileByIdUploadSessions(fileId, body) {
+    async createFileVersionUploadSession(fileId, body) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += '/' + pathEscape(fileId);
@@ -48,8 +48,8 @@ export class ChunkedUploadsManager {
         let req = this.session.newRequest("PUT", url);
         req = runtime.withHeader(req, "digest", digest);
         req = runtime.withHeader(req, "content-range", contentRange);
-        void body;
-        req = runtime.withStreamBody(req, runtime.Stream.empty(), 'application/octet-stream');
+        const fileBytes = new Uint8Array(await body.arrayBuffer());
+        req = runtime.withStreamBody(req, new runtime.Stream(fileBytes), 'application/octet-stream');
         const resp = await this.session.fetch(req);
         const data = runtime.responseBytes(resp);
         return JSON.parse(new TextDecoder().decode(data));

package/dist/esm/managers/search.js

@@ -7,7 +7,7 @@ export class SearchManager {
     constructor(session) {
         this.session = session;
     }
-    async createMetadataQueryExecuteRead(body) {
+    async queryByMetadata(body) {
         let url = this.session.baseUrl("api");
         url += "/metadata_queries";
         url += "/execute_read";

package/dist/esm/managers/transfer.js

@@ -7,7 +7,7 @@ export class TransferManager {
     constructor(session) {
         this.session = session;
     }
-    async updateUserFolder0(userId, body, opts) {
+    async transferFolders(userId, body, opts) {
         let url = this.session.baseUrl("api");
         url += "/users";
         url += '/' + pathEscape(userId);

package/dist/esm/managers/uploads.js

@@ -7,7 +7,7 @@ export class UploadsManager {
     constructor(session) {
         this.session = session;
     }
-    async createFileContent(fileId, body, opts) {
+    async uploadFileVersion(fileId, body, opts) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += '/' + pathEscape(fileId);
@@ -29,7 +29,7 @@ export class UploadsManager {
         const data = runtime.responseBytes(resp);
         return JSON.parse(new TextDecoder().decode(data));
     }
-    async createFileContent2(body, opts) {
+    async uploadFile(body, opts) {
         let url = this.session.baseUrl("upload");
         url += "/files";
         url += "/content";

package/dist/types/chunked_upload.d.ts

@@ -0,0 +1,21 @@
+import type { Client } from './client.js';
+import type * as models from './models/index.js';
+/**
+ * ChunkedUpload orchestrates a Box chunked (multipart) upload over a Client: it
+ * creates an upload session, uploads the content's parts with bounded
+ * concurrency, and commits — for a new file (upload) or a new version of an
+ * existing file (uploadVersion). Box requires chunked upload for files at or
+ * above its minimum session size; smaller files use the single-shot endpoints.
+ */
+export declare class ChunkedUpload {
+    private readonly client;
+    /** Bounds parts in flight, capping peak memory. */
+    private readonly maxConcurrent;
+    constructor(client: Client);
+    /** Upload content as a new file named fileName into folderId. */
+    upload(content: Uint8Array, fileName: string, folderId: string): Promise<models.schemas.Files>;
+    /** Upload content as a new version of the existing file fileId. */
+    uploadVersion(content: Uint8Array, fileName: string, fileId: string): Promise<models.schemas.Files>;
+    private finish;
+    private uploadPart;
+}

package/dist/types/index.d.ts

@@ -2,4 +2,6 @@ export { Client } from './client.js';
 export * as models from './models/index.js';
 export * as managers from './managers/index.js';
 export * as runtime from './runtime.js';
+export * as auth from './auth.js';
 export * as buildinfo from './buildinfo.js';
+export { ChunkedUpload } from './chunked_upload.js';

package/dist/types/managers/chunked_uploads.d.ts

@@ -14,8 +14,8 @@ export interface ChunkedUploadsManagerCommitFileUploadSessionOptions {
 export declare class ChunkedUploadsManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createFileUploadSessions(body: models.schemas.FileUploadSessionsCreateRequest): Promise<models.schemas.UploadSession>;
-    createFileByIdUploadSessions(fileId: string, body: models.schemas.FileIdUploadSessionsCreateRequest): Promise<models.schemas.UploadSession>;
+    createFileUploadSession(body: models.schemas.FileUploadSessionCreateRequest): Promise<models.schemas.UploadSession>;
+    createFileVersionUploadSession(fileId: string, body: models.schemas.FileVersionUploadSessionCreateRequest): Promise<models.schemas.UploadSession>;
     getFileUploadSession(uploadSessionId: string): Promise<models.schemas.UploadSession>;
     updateFileUploadSession(uploadSessionId: string, digest: string, contentRange: string, body: Blob): Promise<models.schemas.UploadedPart>;
     deleteFileUploadSession(uploadSessionId: string): Promise<void>;

package/dist/types/managers/search.d.ts

@@ -28,6 +28,6 @@ export interface SearchManagerGetOptions {
 export declare class SearchManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createMetadataQueryExecuteRead(body: models.schemas.MetadataQuery): Promise<models.schemas.MetadataQueryResults>;
+    queryByMetadata(body: models.schemas.MetadataQuery): Promise<models.schemas.MetadataQueryResults>;
     get(opts?: SearchManagerGetOptions): Promise<models.schemas.SearchResultsResponse>;
 }

package/dist/types/managers/transfer.d.ts

@@ -1,7 +1,7 @@
 import * as runtime from '../runtime.js';
 import type * as models from '../models/index.js';
-/** Optional parameters for TransferManager.updateUserFolder0. */
-export interface TransferManagerUpdateUserFolder0Options {
+/** Optional parameters for TransferManager.transferFolders. */
+export interface TransferManagerTransferFoldersOptions {
     fields?: Array<string>;
     notify?: boolean;
 }
@@ -9,5 +9,5 @@ export interface TransferManagerUpdateUserFolder0Options {
 export declare class TransferManager {
     private readonly session;
     constructor(session: runtime.Client);
-    updateUserFolder0(userId: string, body: models.schemas.UserFolder0UpdateRequest, opts?: TransferManagerUpdateUserFolder0Options): Promise<models.schemas.FolderFull>;
+    transferFolders(userId: string, body: models.schemas.UserFolder0UpdateRequest, opts?: TransferManagerTransferFoldersOptions): Promise<models.schemas.FolderFull>;
 }

package/dist/types/managers/uploads.d.ts

@@ -1,13 +1,13 @@
 import * as runtime from '../runtime.js';
 import type * as models from '../models/index.js';
-/** Optional parameters for UploadsManager.createFileContent. */
-export interface UploadsManagerCreateFileContentOptions {
+/** Optional parameters for UploadsManager.uploadFileVersion. */
+export interface UploadsManagerUploadFileVersionOptions {
     "if-match"?: string;
     fields?: Array<string>;
     "content-md5"?: string;
 }
-/** Optional parameters for UploadsManager.createFileContent2. */
-export interface UploadsManagerCreateFileContent2Options {
+/** Optional parameters for UploadsManager.uploadFile. */
+export interface UploadsManagerUploadFileOptions {
     fields?: Array<string>;
     "content-md5"?: string;
 }
@@ -15,7 +15,7 @@ export interface UploadsManagerCreateFileContent2Options {
 export declare class UploadsManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createFileContent(fileId: string, body: models.schemas.FileIdContentCreateRequest, opts?: UploadsManagerCreateFileContentOptions): Promise<models.schemas.Files>;
-    createFileContent2(body: models.schemas.FileContentCreateRequest, opts?: UploadsManagerCreateFileContent2Options): Promise<models.schemas.Files>;
+    uploadFileVersion(fileId: string, body: models.schemas.FileIdContentCreateRequest, opts?: UploadsManagerUploadFileVersionOptions): Promise<models.schemas.Files>;
+    uploadFile(body: models.schemas.FileContentCreateRequest, opts?: UploadsManagerUploadFileOptions): Promise<models.schemas.Files>;
     optionFileContent(body: models.schemas.OptionFileContentRequest): Promise<models.schemas.UploadUrl>;
 }

package/dist/types/models/schemas.d.ts

@@ -3059,12 +3059,12 @@ export interface OptionFileContentRequest {
     size?: number;
     parent?: PostFileIdParent;
 }
-export interface FileUploadSessionsCreateRequest {
+export interface FileUploadSessionCreateRequest {
     folder_id: string;
     file_size: number;
     file_name: string;
 }
-export interface FileIdUploadSessionsCreateRequest {
+export interface FileVersionUploadSessionCreateRequest {
     file_size: number;
     file_name?: string;
 }

package/docs/auth.md

@@ -3,16 +3,16 @@
 
 Build a `Client` from one of the four Box auth flows. Each flow is an `Auth`
 the runtime uses to fetch a bearer token; the network layer refreshes on a
-`401` and retries once. The flow builders live in the runtime package and are
-passed straight to `new Client(...)`.
+`401` and retries once. The flow builders live in the `auth` namespace (JWT on
+the Node-only `./jwt` subpath) and are passed straight to `new Client(...)`.
 
 ## Developer Token
 
 A fixed token from the Developer Console, for quick local testing:
 
 ```ts
-import { developerToken } from 'box-gantry-runtime';
-const client = new Client(developerToken('DEVELOPER_TOKEN'));
+import { auth } from '@unofficialbox/box-open-sdk';
+const client = new Client(auth.developerToken('DEVELOPER_TOKEN'));
 ```
 
 ## Client Credentials Grant (server auth, no key)
@@ -21,8 +21,8 @@ Set exactly one subject — `enterpriseId` for the service account, or `userId`
 to act as a managed user:
 
 ```ts
-import { clientCredentials } from 'box-gantry-runtime';
-const client = new Client(clientCredentials({
+import { auth } from '@unofficialbox/box-open-sdk';
+const client = new Client(auth.clientCredentials({
 clientId: 'CLIENT_ID',
 clientSecret: 'CLIENT_SECRET',
 enterpriseId: 'ENTERPRISE_ID',
@@ -36,7 +36,7 @@ loudly at construction. It reaches `node:crypto`, so it is a Node-only leaf
 imported from the runtime's `./jwt` entry point and returns a promise:
 
 ```ts
-import { jwtAuth } from 'box-gantry-runtime/jwt';
+import { jwtAuth } from '@unofficialbox/box-open-sdk/jwt';
 const auth = await jwtAuth({
 clientId: 'CLIENT_ID',
 clientSecret: 'CLIENT_SECRET',
@@ -53,8 +53,8 @@ Redirect the user to the authorize URL, exchange the returned code, then reuse
 the rotated refresh token on later runs (persist it via `onRefresh`):
 
 ```ts
-import { oauth } from 'box-gantry-runtime';
+import { auth } from '@unofficialbox/box-open-sdk';
 // later runs: resume from the stored refresh token.
-const auth = oauth({ clientId: 'CLIENT_ID', clientSecret: 'CLIENT_SECRET' }, storedRefreshToken);
-const client = new Client(auth);
+const source = auth.oauth({ clientId: 'CLIENT_ID', clientSecret: 'CLIENT_SECRET' }, storedRefreshToken);
+const client = new Client(source);
 ```