@unofficialbox/box-open-sdk 0.3.1 → 0.4.0

package/dist/esm/runtime.js

@@ -55,6 +55,8 @@ export class Client {
     auth;
     baseUrls;
     maxRetries;
+    fetchImpl;
+    defaultHeaders;
     constructor(auth, options = {}) {
         this.auth = auth;
         const maxRetries = options.maxRetries ?? 5;
@@ -63,6 +65,8 @@ export class Client {
         }
         this.maxRetries = maxRetries;
         this.baseUrls = { ...DEFAULT_BASE_URLS, ...(options.baseUrls ?? {}) };
+        this.fetchImpl = options.fetch ?? fetch;
+        this.defaultHeaders = { ...(options.headers ?? {}) };
     }
     /** The configured base URL for a D-106 class, without a trailing slash. */
     baseUrl(name) {
@@ -93,13 +97,14 @@ export class Client {
         let refreshed = false;
         let lastError;
         for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-            const headers = new Headers(request.headers);
+            const headers = new Headers(this.defaultHeaders);
+            request.headers.forEach((value, name) => headers.set(name, value));
             headers.set('Authorization', `Bearer ${token}`);
             // `httpResponse` is the platform `Response` (via inference — the name is
             // shadowed by this module's `Response` class, so it is never annotated).
             let httpResponse;
             try {
-                httpResponse = await fetch(url, {
+                httpResponse = await this.fetchImpl(url, {
                     method: request.method,
                     headers,
                     // A `Uint8Array` is a valid `BodyInit` at runtime; the cast bridges
@@ -123,7 +128,7 @@ export class Client {
             const response = new Response(httpResponse.status, httpResponse.headers, bodyBytes);
             // A single force-refresh on 401: re-acquire past the token cache so the
             // retry doesn't just resend the same rejected token.
-            if (response.status === 401 && !refreshed) {
+            if (response.status === 401 && !refreshed && attempt < this.maxRetries) {
                 refreshed = true;
                 token = await this.auth.forceRefresh(token);
                 continue;

package/dist/esm/tokens.js

@@ -67,9 +67,11 @@ export class CachedToken {
  * token acquisition never escapes the runtime's error contract. The optional
  * `signal` cancels an explicit caller-initiated exchange (`exchangeCode`); the
  * cached flows do not thread one, so a shared refresh is never bound to a single
- * request's cancellation.
+ * request's cancellation. `fetchImpl` defaults to the global `fetch`; a caller
+ * building an `Auth` with a custom transport (matching the runtime `Client`'s
+ * own `fetch` override) passes it through so auth traffic is observable too.
  */
-export async function postTokenForm(tokenUrl, form, signal) {
+export async function postTokenForm(tokenUrl, form, signal, fetchImpl = fetch) {
     // An internal deadline independent of the caller's signal, combined with it
     // when present. It also covers the body read, since the signal aborts an
     // in-progress `fetch` (including body streaming). `AbortSignal.timeout` owns
@@ -79,7 +81,7 @@ export async function postTokenForm(tokenUrl, form, signal) {
     let response;
     let text;
     try {
-        response = await fetch(tokenUrl, {
+        response = await fetchImpl(tokenUrl, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/x-www-form-urlencoded',

package/dist/types/auth.d.ts

@@ -18,6 +18,10 @@ export interface CcgConfig {
     userId?: string;
     /** Optional; defaults to Box's token endpoint. */
     tokenUrl?: string;
+    /** Override the platform `fetch` used for the token exchange — e.g. to match
+     * the runtime `Client`'s own transport override. Defaults to the global
+     * `fetch`. */
+    fetch?: typeof fetch;
 }
 /** Build a CCG `Auth`. Requires a subject: `enterpriseId` or `userId`. */
 export declare function clientCredentials(config: CcgConfig): Auth;
@@ -37,6 +41,10 @@ export interface OAuthConfig {
      * stale, already-invalidated token.
      */
     onRefresh?: (refreshToken: string) => void;
+    /** Override the platform `fetch` used for token exchanges — e.g. to match
+     * the runtime `Client`'s own transport override. Defaults to the global
+     * `fetch`. */
+    fetch?: typeof fetch;
 }
 /**
  * Build the URL to redirect a user to so they can grant access. `state` is

package/dist/types/buildinfo.d.ts

@@ -1,6 +1,6 @@
 /** The box-gantry engine version that generated this SDK. */
 export declare const ENGINE = "0.1.0";
 /** Fingerprint of the input spec set. */
-export declare const SPEC_FINGERPRINT = "ee7d55aedefe2fa0";
+export declare const SPEC_FINGERPRINT = "3fb3510fe12f2f80";
 /** The target language key (FR-4). */
 export declare const TARGET = "typescript";

package/dist/types/client.d.ts

@@ -48,6 +48,7 @@ import { MetadataCascadePoliciesManager } from './managers/metadata_cascade_poli
 import { MetadataTaxonomiesManager } from './managers/metadata_taxonomies.js';
 import { MetadataTemplatesManager } from './managers/metadata_templates.js';
 import { NotesManager } from './managers/notes.js';
+import { QueryManager } from './managers/query.js';
 import { RecentItemsManager } from './managers/recent_items.js';
 import { RetentionPoliciesManager } from './managers/retention_policies.js';
 import { RetentionPolicyAssignmentsManager } from './managers/retention_policy_assignments.js';
@@ -135,6 +136,7 @@ export declare class Client {
     readonly metadataTaxonomies: MetadataTaxonomiesManager;
     readonly metadataTemplates: MetadataTemplatesManager;
     readonly notes: NotesManager;
+    readonly query: QueryManager;
     readonly recentItems: RecentItemsManager;
     readonly retentionPolicies: RetentionPoliciesManager;
     readonly retentionPolicyAssignments: RetentionPolicyAssignmentsManager;

package/dist/types/jwt.d.ts

@@ -14,6 +14,10 @@ export interface JwtConfig {
     userId?: string;
     /** Optional; defaults to Box's token endpoint. */
     tokenUrl?: string;
+    /** Override the platform `fetch` used for the token exchange — e.g. to match
+     * the runtime `Client`'s own transport override. Defaults to the global
+     * `fetch`. */
+    fetch?: typeof fetch;
 }
 /**
  * Build a JWT-assertion `Auth`, parsing (and if needed decrypting) the RSA

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

@@ -12,7 +12,7 @@ export declare class ArchivesManager {
     /** Iterate every `models.schemas.Archive` across pages, threading the marker cursor. */
     list(opts?: ArchivesManagerListOptions): AsyncIterableIterator<models.schemas.Archive>;
     private listPage;
-    create(body: models.schemas.ArchiveCreateRequest): Promise<models.schemas.Archive>;
-    update(archiveId: string, body: models.schemas.ArchiveUpdateRequest): Promise<models.schemas.Archive>;
+    create(body: models.schemas.CreateArchiveRequest): Promise<models.schemas.Archive>;
+    update(archiveId: string, body: models.schemas.UpdateArchiveRequest): Promise<models.schemas.Archive>;
     delete_(archiveId: string): Promise<void>;
 }

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

@@ -5,6 +5,6 @@ export declare class AvatarsManager {
     private readonly session;
     constructor(session: runtime.Client);
     getUserAvatar(userId: string): Promise<runtime.Stream>;
-    createUserAvatar(userId: string, body: models.schemas.UserAvatarCreateRequest): Promise<models.schemas.UserAvatar>;
+    createUserAvatar(userId: string, body: models.schemas.CreateUserAvatarRequest): Promise<models.schemas.UserAvatar>;
     deleteUserAvatar(userId: string): Promise<void>;
 }

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

@@ -14,13 +14,13 @@ export interface ChunkedUploadsManagerCommitFileUploadSessionOptions {
 export declare class ChunkedUploadsManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createFileUploadSession(body: models.schemas.FileUploadSessionCreateRequest): Promise<models.schemas.UploadSession>;
-    createFileVersionUploadSession(fileId: string, body: models.schemas.FileVersionUploadSessionCreateRequest): Promise<models.schemas.UploadSession>;
+    createFileUploadSession(body: models.schemas.CreateFileUploadSessionRequest): Promise<models.schemas.UploadSession>;
+    createFileVersionUploadSession(fileId: string, body: models.schemas.CreateFileVersionUploadSessionRequest): 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>;
     /** Iterate every `models.schemas.UploadPart` across pages, threading the offset cursor. */
     listFileUploadSessionParts(uploadSessionId: string, opts?: ChunkedUploadsManagerListFileUploadSessionPartsOptions): AsyncIterableIterator<models.schemas.UploadPart>;
     private listFileUploadSessionPartsPage;
-    commitFileUploadSession(uploadSessionId: string, digest: string, body: models.schemas.FileUploadSessionCommitRequest, opts?: ChunkedUploadsManagerCommitFileUploadSessionOptions): Promise<models.schemas.Files>;
+    commitFileUploadSession(uploadSessionId: string, digest: string, body: models.schemas.CommitFileUploadSessionRequest, opts?: ChunkedUploadsManagerCommitFileUploadSessionOptions): Promise<models.schemas.Files>;
 }

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

@@ -5,7 +5,7 @@ export declare class ClassificationsManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(): Promise<models.schemas.ClassificationTemplate>;
-    updateAdd(body: Array<models.schemas.ClassificationUpdateRequest>): Promise<models.schemas.ClassificationTemplate>;
-    updateUpdate(body: Array<models.schemas.ClassificationUpdateRequest2>): Promise<models.schemas.ClassificationTemplate>;
-    createMetadataTemplateSchemaClassifications(body: models.schemas.MetadataTemplateSchemaCreateRequest): Promise<models.schemas.ClassificationTemplate>;
+    updateAdd(body: Array<models.schemas.UpdateClassificationAddRequest>): Promise<models.schemas.ClassificationTemplate>;
+    updateUpdate(body: Array<models.schemas.UpdateClassificationUpdateRequest>): Promise<models.schemas.ClassificationTemplate>;
+    createMetadataTemplateSchemaClassifications(body: models.schemas.CreateMetadataTemplateSchemaClassificationsRequest): Promise<models.schemas.ClassificationTemplate>;
 }

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

@@ -1,7 +1,7 @@
 import * as runtime from '../runtime.js';
 import type * as models from '../models/index.js';
-/** Optional parameters for CollaborationAllowlistEntriesManager.listCollaborationWhitelistEntries. */
-export interface CollaborationAllowlistEntriesManagerListCollaborationWhitelistEntriesOptions {
+/** Optional parameters for CollaborationAllowlistEntriesManager.list. */
+export interface CollaborationAllowlistEntriesManagerListOptions {
     marker?: string;
     limit?: number;
 }
@@ -10,9 +10,9 @@ export declare class CollaborationAllowlistEntriesManager {
     private readonly session;
     constructor(session: runtime.Client);
     /** Iterate every `models.schemas.CollaborationAllowlistEntry` across pages, threading the marker cursor. */
-    listCollaborationWhitelistEntries(opts?: CollaborationAllowlistEntriesManagerListCollaborationWhitelistEntriesOptions): AsyncIterableIterator<models.schemas.CollaborationAllowlistEntry>;
-    private listCollaborationWhitelistEntriesPage;
-    createCollaborationWhitelistEntries(body: models.schemas.CollaborationWhitelistEntriesCreateRequest): Promise<models.schemas.CollaborationAllowlistEntry>;
-    getCollaborationWhitelistEntry(collaborationWhitelistEntryId: string): Promise<models.schemas.CollaborationAllowlistEntry>;
-    deleteCollaborationWhitelistEntry(collaborationWhitelistEntryId: string): Promise<void>;
+    list(opts?: CollaborationAllowlistEntriesManagerListOptions): AsyncIterableIterator<models.schemas.CollaborationAllowlistEntry>;
+    private listPage;
+    create(body: models.schemas.CreateCollaborationAllowlistEntryRequest): Promise<models.schemas.CollaborationAllowlistEntry>;
+    get(collaborationWhitelistEntryId: string): Promise<models.schemas.CollaborationAllowlistEntry>;
+    delete_(collaborationWhitelistEntryId: string): Promise<void>;
 }

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

@@ -1,7 +1,7 @@
 import * as runtime from '../runtime.js';
 import type * as models from '../models/index.js';
-/** Optional parameters for CollaborationAllowlistExemptTargetsManager.listCollaborationWhitelistExemptTargets. */
-export interface CollaborationAllowlistExemptTargetsManagerListCollaborationWhitelistExemptTargetsOptions {
+/** Optional parameters for CollaborationAllowlistExemptTargetsManager.list. */
+export interface CollaborationAllowlistExemptTargetsManagerListOptions {
     marker?: string;
     limit?: number;
 }
@@ -10,9 +10,9 @@ export declare class CollaborationAllowlistExemptTargetsManager {
     private readonly session;
     constructor(session: runtime.Client);
     /** Iterate every `models.schemas.CollaborationAllowlistExemptTarget` across pages, threading the marker cursor. */
-    listCollaborationWhitelistExemptTargets(opts?: CollaborationAllowlistExemptTargetsManagerListCollaborationWhitelistExemptTargetsOptions): AsyncIterableIterator<models.schemas.CollaborationAllowlistExemptTarget>;
-    private listCollaborationWhitelistExemptTargetsPage;
-    createCollaborationWhitelistExemptTargets(body: models.schemas.CollaborationWhitelistExemptTargetsCreateRequest): Promise<models.schemas.CollaborationAllowlistExemptTarget>;
-    getCollaborationWhitelistExemptTarget(collaborationWhitelistExemptTargetId: string): Promise<models.schemas.CollaborationAllowlistExemptTarget>;
-    deleteCollaborationWhitelistExemptTarget(collaborationWhitelistExemptTargetId: string): Promise<void>;
+    list(opts?: CollaborationAllowlistExemptTargetsManagerListOptions): AsyncIterableIterator<models.schemas.CollaborationAllowlistExemptTarget>;
+    private listPage;
+    create(body: models.schemas.CreateCollaborationAllowlistExemptTargetRequest): Promise<models.schemas.CollaborationAllowlistExemptTarget>;
+    get(collaborationWhitelistExemptTargetId: string): Promise<models.schemas.CollaborationAllowlistExemptTarget>;
+    delete_(collaborationWhitelistExemptTargetId: string): Promise<void>;
 }

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

@@ -26,7 +26,7 @@ export declare class CommentsManager {
     listFile(fileId: string, opts?: CommentsManagerListFileOptions): AsyncIterableIterator<models.schemas.CommentFull>;
     private listFilePage;
     get(commentId: string, opts?: CommentsManagerGetOptions): Promise<models.schemas.CommentFull>;
-    update(commentId: string, body: models.schemas.CommentUpdateRequest, opts?: CommentsManagerUpdateOptions): Promise<models.schemas.CommentFull>;
+    update(commentId: string, body: models.schemas.UpdateCommentRequest, opts?: CommentsManagerUpdateOptions): Promise<models.schemas.CommentFull>;
     delete_(commentId: string): Promise<void>;
-    create(body: models.schemas.CommentCreateRequest, opts?: CommentsManagerCreateOptions): Promise<models.schemas.CommentFull>;
+    create(body: models.schemas.CreateCommentRequest, opts?: CommentsManagerCreateOptions): Promise<models.schemas.CommentFull>;
 }

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

@@ -5,6 +5,6 @@ export declare class EmailAliasesManager {
     private readonly session;
     constructor(session: runtime.Client);
     listUser(userId: string): Promise<models.schemas.EmailAliases>;
-    createUser(userId: string, body: models.schemas.UserIdCreateRequest): Promise<models.schemas.EmailAlias>;
+    createUser(userId: string, body: models.schemas.CreateUserIdRequest): Promise<models.schemas.EmailAlias>;
     deleteUser(userId: string, emailAliasId: string): Promise<void>;
 }

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

@@ -5,7 +5,7 @@ export declare class FileClassificationsManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(fileId: string): Promise<models.schemas.Classification>;
-    update(fileId: string, body: Array<models.schemas.FileClassificationUpdateRequest>): Promise<models.schemas.Classification>;
-    create(fileId: string, body: models.schemas.FileClassificationCreateRequest): Promise<models.schemas.Classification>;
+    update(fileId: string, body: Array<models.schemas.UpdateFileClassificationRequest>): Promise<models.schemas.Classification>;
+    create(fileId: string, body: models.schemas.CreateFileClassificationRequest): Promise<models.schemas.Classification>;
     delete_(fileId: string): Promise<void>;
 }

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

@@ -13,8 +13,8 @@ export declare class FileMetadataManager {
     private readonly session;
     constructor(session: runtime.Client);
     listFileMetadata(fileId: string, opts?: FileMetadataManagerListFileMetadataOptions): Promise<models.schemas.Metadatas>;
-    getFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string, opts?: FileMetadataManagerGetFileMetadataOptions): Promise<models.schemas.MetadataFull>;
-    updateFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string, body: Array<models.schemas.FileMetadataUpdateRequest>): Promise<models.schemas.MetadataFull>;
-    createFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string, body: Record<string, unknown>): Promise<models.schemas.MetadataFull>;
-    deleteFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string): Promise<void>;
+    getFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string, opts?: FileMetadataManagerGetFileMetadataOptions): Promise<models.schemas.MetadataFull>;
+    updateFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string, body: Array<models.schemas.UpdateFileMetadataRequest>): Promise<models.schemas.MetadataFull>;
+    createFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string, body: Record<string, unknown>): Promise<models.schemas.MetadataFull>;
+    deleteFileMetadata(fileId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string): Promise<void>;
 }

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

@@ -26,7 +26,7 @@ export declare class FileVersionsManager {
     listFileVersions(fileId: string, opts?: FileVersionsManagerListFileVersionsOptions): AsyncIterableIterator<models.schemas.FileVersionFull>;
     private listFileVersionsPage;
     getFileVersion(fileId: string, fileVersionId: string, opts?: FileVersionsManagerGetFileVersionOptions): Promise<models.schemas.FileVersionFull>;
-    updateFileVersion(fileId: string, fileVersionId: string, body: models.schemas.FileVersionUpdateRequest): Promise<models.schemas.FileVersionFull>;
+    updateFileVersion(fileId: string, fileVersionId: string, body: models.schemas.UpdateFileVersionRequest): Promise<models.schemas.FileVersionFull>;
     deleteFileVersion(fileId: string, fileVersionId: string, opts?: FileVersionsManagerDeleteFileVersionOptions): Promise<void>;
-    createFileVersionCurrent(fileId: string, body: models.schemas.FileVersionCurrentCreateRequest, opts?: FileVersionsManagerCreateFileVersionCurrentOptions): Promise<models.schemas.FileVersionFull>;
+    createFileVersionCurrent(fileId: string, body: models.schemas.CreateFileVersionCurrentRequest, opts?: FileVersionsManagerCreateFileVersionCurrentOptions): Promise<models.schemas.FileVersionFull>;
 }

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

@@ -5,6 +5,6 @@ export declare class FileWatermarksManager {
     private readonly session;
     constructor(session: runtime.Client);
     getFileWatermark(fileId: string): Promise<models.schemas.Watermark>;
-    updateFileWatermark(fileId: string, body: models.schemas.FileWatermarkUpdateRequest): Promise<models.schemas.Watermark>;
+    updateFileWatermark(fileId: string, body: models.schemas.UpdateFileWatermarkRequest): Promise<models.schemas.Watermark>;
     deleteFileWatermark(fileId: string): Promise<void>;
 }

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

@@ -32,8 +32,8 @@ export declare class FilesManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(fileId: string, opts?: FilesManagerGetOptions): Promise<models.schemas.FileFull>;
-    update(fileId: string, body: models.schemas.FileUpdateRequest, opts?: FilesManagerUpdateOptions): Promise<models.schemas.FileFull>;
+    update(fileId: string, body: models.schemas.UpdateFileRequest, opts?: FilesManagerUpdateOptions): Promise<models.schemas.FileFull>;
     delete_(fileId: string, opts?: FilesManagerDeleteOptions): Promise<void>;
-    copy(fileId: string, body: models.schemas.FileCopyRequest, opts?: FilesManagerCopyOptions): Promise<models.schemas.FileFull>;
+    copy(fileId: string, body: models.schemas.CopyFileRequest, opts?: FilesManagerCopyOptions): Promise<models.schemas.FileFull>;
     getThumbnail(fileId: string, extension: models.schemas.GetIdThumbnailIdExtension, opts?: FilesManagerGetThumbnailOptions): Promise<runtime.Stream>;
 }

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

@@ -5,7 +5,7 @@ export declare class FolderClassificationsManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(folderId: string): Promise<models.schemas.Classification>;
-    update(folderId: string, body: Array<models.schemas.FileClassificationUpdateRequest>): Promise<models.schemas.Classification>;
-    create(folderId: string, body: models.schemas.FileClassificationCreateRequest): Promise<models.schemas.Classification>;
+    update(folderId: string, body: Array<models.schemas.UpdateFileClassificationRequest>): Promise<models.schemas.Classification>;
+    create(folderId: string, body: models.schemas.CreateFileClassificationRequest): Promise<models.schemas.Classification>;
     delete_(folderId: string): Promise<void>;
 }

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

@@ -5,6 +5,6 @@ export declare class FolderLocksManager {
     private readonly session;
     constructor(session: runtime.Client);
     list(folderId: string): Promise<models.schemas.FolderLocks>;
-    create(body: models.schemas.FolderLockCreateRequest): Promise<models.schemas.FolderLock>;
+    create(body: models.schemas.CreateFolderLockRequest): Promise<models.schemas.FolderLock>;
     delete_(folderLockId: string): Promise<void>;
 }

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

@@ -9,8 +9,8 @@ export declare class FolderMetadataManager {
     private readonly session;
     constructor(session: runtime.Client);
     listFolderMetadata(folderId: string, opts?: FolderMetadataManagerListFolderMetadataOptions): Promise<models.schemas.Metadatas>;
-    getFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string): Promise<models.schemas.MetadataFull>;
-    updateFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string, body: Array<models.schemas.FileMetadataUpdateRequest>): Promise<models.schemas.MetadataFull>;
-    createFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string, body: Record<string, unknown>): Promise<models.schemas.MetadataFull>;
-    deleteFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string): Promise<void>;
+    getFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string): Promise<models.schemas.MetadataFull>;
+    updateFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string, body: Array<models.schemas.UpdateFileMetadataRequest>): Promise<models.schemas.MetadataFull>;
+    createFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string, body: Record<string, unknown>): Promise<models.schemas.MetadataFull>;
+    deleteFolderMetadata(folderId: string, scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string): Promise<void>;
 }

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

@@ -5,6 +5,6 @@ export declare class FolderWatermarksManager {
     private readonly session;
     constructor(session: runtime.Client);
     getFolderWatermark(folderId: string): Promise<models.schemas.Watermark>;
-    updateFolderWatermark(folderId: string, body: models.schemas.FileWatermarkUpdateRequest): Promise<models.schemas.Watermark>;
+    updateFolderWatermark(folderId: string, body: models.schemas.UpdateFileWatermarkRequest): Promise<models.schemas.Watermark>;
     deleteFolderWatermark(folderId: string): Promise<void>;
 }

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

@@ -44,11 +44,11 @@ export declare class FoldersManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(folderId: string, opts?: FoldersManagerGetOptions): Promise<models.schemas.FolderFull>;
-    update(folderId: string, body: models.schemas.FolderUpdateRequest, opts?: FoldersManagerUpdateOptions): Promise<models.schemas.FolderFull>;
+    update(folderId: string, body: models.schemas.UpdateFolderRequest, opts?: FoldersManagerUpdateOptions): Promise<models.schemas.FolderFull>;
     delete_(folderId: string, opts?: FoldersManagerDeleteOptions): Promise<void>;
     /** Iterate every `models.schemas.Item` across pages, threading the marker cursor. */
     listItems(folderId: string, opts?: FoldersManagerListItemsOptions): AsyncIterableIterator<models.schemas.Item>;
     private listItemsPage;
-    create(body: models.schemas.FolderCreateRequest, opts?: FoldersManagerCreateOptions): Promise<models.schemas.FolderFull>;
-    copy(folderId: string, body: models.schemas.FolderCopyRequest, opts?: FoldersManagerCopyOptions): Promise<models.schemas.FolderFull>;
+    create(body: models.schemas.CreateFolderRequest, opts?: FoldersManagerCreateOptions): Promise<models.schemas.FolderFull>;
+    copy(folderId: string, body: models.schemas.CopyFolderRequest, opts?: FoldersManagerCopyOptions): Promise<models.schemas.FolderFull>;
 }

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

@@ -26,8 +26,8 @@ export declare class GroupsManager {
     /** Iterate every `models.schemas.GroupFull` across pages, threading the offset cursor. */
     list(opts?: GroupsManagerListOptions): AsyncIterableIterator<models.schemas.GroupFull>;
     private listPage;
-    create(body: models.schemas.GroupCreateRequest, opts?: GroupsManagerCreateOptions): Promise<models.schemas.GroupFull>;
+    create(body: models.schemas.CreateGroupRequest, opts?: GroupsManagerCreateOptions): Promise<models.schemas.GroupFull>;
     get(groupId: string, opts?: GroupsManagerGetOptions): Promise<models.schemas.GroupFull>;
-    update(groupId: string, body: models.schemas.GroupUpdateRequest, opts?: GroupsManagerUpdateOptions): Promise<models.schemas.GroupFull>;
+    update(groupId: string, body: models.schemas.UpdateGroupRequest, opts?: GroupsManagerUpdateOptions): Promise<models.schemas.GroupFull>;
     delete_(groupId: string): Promise<void>;
 }

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

@@ -47,6 +47,7 @@ export * from './metadata_cascade_policies.js';
 export * from './metadata_taxonomies.js';
 export * from './metadata_templates.js';
 export * from './notes.js';
+export * from './query.js';
 export * from './recent_items.js';
 export * from './retention_policies.js';
 export * from './retention_policy_assignments.js';

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

@@ -25,10 +25,10 @@ export declare class IntegrationMappingsManager {
     listSlack(opts?: IntegrationMappingsManagerListSlackOptions): AsyncIterableIterator<models.schemas.IntegrationMapping>;
     private listSlackPage;
     createSlack(body: models.schemas.IntegrationMappingSlackCreateRequest): Promise<models.schemas.IntegrationMapping>;
-    updateSlack(integrationMappingId: string, body: models.schemas.SlackUpdateRequest): Promise<models.schemas.IntegrationMapping>;
+    updateSlack(integrationMappingId: string, body: models.schemas.UpdateSlackRequest): Promise<models.schemas.IntegrationMapping>;
     deleteSlack(integrationMappingId: string): Promise<void>;
     listTeams(opts?: IntegrationMappingsManagerListTeamsOptions): Promise<models.schemas.IntegrationMappingsTeams>;
     createTeams(body: models.schemas.IntegrationMappingTeamsCreateRequest): Promise<models.schemas.IntegrationMappingTeams>;
-    updateTeam(integrationMappingId: string, body: models.schemas.TeamUpdateRequest): Promise<models.schemas.IntegrationMappingTeams>;
+    updateTeam(integrationMappingId: string, body: models.schemas.UpdateTeamRequest): Promise<models.schemas.IntegrationMappingTeams>;
     deleteTeam(integrationMappingId: string): Promise<void>;
 }

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

@@ -12,6 +12,6 @@ export interface InvitesManagerGetOptions {
 export declare class InvitesManager {
     private readonly session;
     constructor(session: runtime.Client);
-    create(body: models.schemas.InviteCreateRequest, opts?: InvitesManagerCreateOptions): Promise<models.schemas.Invite>;
+    create(body: models.schemas.CreateInviteRequest, opts?: InvitesManagerCreateOptions): Promise<models.schemas.Invite>;
     get(inviteId: string, opts?: InvitesManagerGetOptions): Promise<models.schemas.Invite>;
 }

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

@@ -14,8 +14,8 @@ export declare class LegalHoldPoliciesManager {
     /** Iterate every `models.schemas.LegalHoldPolicy` across pages, threading the marker cursor. */
     list(opts?: LegalHoldPoliciesManagerListOptions): AsyncIterableIterator<models.schemas.LegalHoldPolicy>;
     private listPage;
-    create(body: models.schemas.LegalHoldPolicyCreateRequest): Promise<models.schemas.LegalHoldPolicy>;
+    create(body: models.schemas.CreateLegalHoldPolicyRequest): Promise<models.schemas.LegalHoldPolicy>;
     get(legalHoldPolicyId: string): Promise<models.schemas.LegalHoldPolicy>;
-    update(legalHoldPolicyId: string, body: models.schemas.LegalHoldPolicyUpdateRequest): Promise<models.schemas.LegalHoldPolicy>;
+    update(legalHoldPolicyId: string, body: models.schemas.UpdateLegalHoldPolicyRequest): Promise<models.schemas.LegalHoldPolicy>;
     delete_(legalHoldPolicyId: string): Promise<void>;
 }

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

@@ -27,7 +27,7 @@ export declare class LegalHoldPolicyAssignmentsManager {
     /** Iterate every `models.schemas.LegalHoldPolicyAssignment` across pages, threading the marker cursor. */
     list(policyId: string, opts?: LegalHoldPolicyAssignmentsManagerListOptions): AsyncIterableIterator<models.schemas.LegalHoldPolicyAssignment>;
     private listPage;
-    create(body: models.schemas.LegalHoldPolicyAssignmentCreateRequest): Promise<models.schemas.LegalHoldPolicyAssignment>;
+    create(body: models.schemas.CreateLegalHoldPolicyAssignmentRequest): Promise<models.schemas.LegalHoldPolicyAssignment>;
     get(legalHoldPolicyAssignmentId: string): Promise<models.schemas.LegalHoldPolicyAssignment>;
     delete_(legalHoldPolicyAssignmentId: string): Promise<void>;
     /** Iterate every `models.schemas.FileMini` across pages, threading the marker cursor. */

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

@@ -10,16 +10,16 @@ export interface MembershipsManagerListGroupOptions {
     limit?: number;
     offset?: number;
 }
-/** Optional parameters for MembershipsManager.createGroup. */
-export interface MembershipsManagerCreateGroupOptions {
+/** Optional parameters for MembershipsManager.createGroupMembership. */
+export interface MembershipsManagerCreateGroupMembershipOptions {
     fields?: Array<string>;
 }
-/** Optional parameters for MembershipsManager.getGroup. */
-export interface MembershipsManagerGetGroupOptions {
+/** Optional parameters for MembershipsManager.getGroupMembership. */
+export interface MembershipsManagerGetGroupMembershipOptions {
     fields?: Array<string>;
 }
-/** Optional parameters for MembershipsManager.updateGroup. */
-export interface MembershipsManagerUpdateGroupOptions {
+/** Optional parameters for MembershipsManager.updateGroupMembership. */
+export interface MembershipsManagerUpdateGroupMembershipOptions {
     fields?: Array<string>;
 }
 /** Operations for the "memberships" API area. */
@@ -32,8 +32,8 @@ export declare class MembershipsManager {
     /** Iterate every `models.schemas.GroupMembership` across pages, threading the offset cursor. */
     listGroup(groupId: string, opts?: MembershipsManagerListGroupOptions): AsyncIterableIterator<models.schemas.GroupMembership>;
     private listGroupPage;
-    createGroup(body: models.schemas.GroupCreateRequest2, opts?: MembershipsManagerCreateGroupOptions): Promise<models.schemas.GroupMembership>;
-    getGroup(groupMembershipId: string, opts?: MembershipsManagerGetGroupOptions): Promise<models.schemas.GroupMembership>;
-    updateGroup(groupMembershipId: string, body: models.schemas.GroupUpdateRequest2, opts?: MembershipsManagerUpdateGroupOptions): Promise<models.schemas.GroupMembership>;
-    deleteGroup(groupMembershipId: string): Promise<void>;
+    createGroupMembership(body: models.schemas.CreateGroupMembershipRequest, opts?: MembershipsManagerCreateGroupMembershipOptions): Promise<models.schemas.GroupMembership>;
+    getGroupMembership(groupMembershipId: string, opts?: MembershipsManagerGetGroupMembershipOptions): Promise<models.schemas.GroupMembership>;
+    updateGroupMembership(groupMembershipId: string, body: models.schemas.UpdateGroupMembershipRequest, opts?: MembershipsManagerUpdateGroupMembershipOptions): Promise<models.schemas.GroupMembership>;
+    deleteGroupMembership(groupMembershipId: string): Promise<void>;
 }

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

@@ -13,8 +13,8 @@ export declare class MetadataCascadePoliciesManager {
     /** Iterate every `models.schemas.MetadataCascadePolicy` across pages, threading the marker cursor. */
     list(folderId: string, opts?: MetadataCascadePoliciesManagerListOptions): AsyncIterableIterator<models.schemas.MetadataCascadePolicy>;
     private listPage;
-    create(body: models.schemas.MetadataCascadePolicyCreateRequest): Promise<models.schemas.MetadataCascadePolicy>;
+    create(body: models.schemas.CreateMetadataCascadePolicyRequest): Promise<models.schemas.MetadataCascadePolicy>;
     get(metadataCascadePolicyId: string): Promise<models.schemas.MetadataCascadePolicy>;
     delete_(metadataCascadePolicyId: string): Promise<void>;
-    apply(metadataCascadePolicyId: string, body: models.schemas.MetadataCascadePolicyApplyRequest): Promise<void>;
+    apply(metadataCascadePolicyId: string, body: models.schemas.ApplyMetadataCascadePolicyRequest): Promise<void>;
 }

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

@@ -30,24 +30,24 @@ export interface MetadataTaxonomiesManagerListMetadataTemplateFieldOptionsOption
 export declare class MetadataTaxonomiesManager {
     private readonly session;
     constructor(session: runtime.Client);
-    create(body: models.schemas.MetadataTaxonomyCreateRequest): Promise<models.schemas.MetadataTaxonomy>;
+    create(body: models.schemas.CreateMetadataTaxonomyRequest): Promise<models.schemas.MetadataTaxonomy>;
     /** Iterate every `models.schemas.MetadataTaxonomy` across pages, threading the marker cursor. */
     list(namespace: string, opts?: MetadataTaxonomiesManagerListOptions): AsyncIterableIterator<models.schemas.MetadataTaxonomy>;
     private listPage;
     get(namespace: string, taxonomyKey: string): Promise<models.schemas.MetadataTaxonomy>;
     delete_(namespace: string, taxonomyKey: string): Promise<void>;
-    update(namespace: string, taxonomyKey: string, body: models.schemas.MetadataTaxonomyUpdateRequest): Promise<models.schemas.MetadataTaxonomy>;
+    update(namespace: string, taxonomyKey: string, body: models.schemas.UpdateMetadataTaxonomyRequest): Promise<models.schemas.MetadataTaxonomy>;
     createLevels(namespace: string, taxonomyKey: string, body: Array<models.schemas.MetadataTaxonomyLevel>): Promise<models.schemas.MetadataTaxonomyLevels>;
-    updateLevel(namespace: string, taxonomyKey: string, levelIndex: number, body: models.schemas.LevelUpdateRequest): Promise<models.schemas.MetadataTaxonomyLevel>;
-    appendLevels(namespace: string, taxonomyKey: string, body: models.schemas.LevelUpdateRequest): Promise<models.schemas.MetadataTaxonomyLevels>;
+    updateLevel(namespace: string, taxonomyKey: string, levelIndex: number, body: models.schemas.UpdateLevelRequest): Promise<models.schemas.MetadataTaxonomyLevel>;
+    appendLevels(namespace: string, taxonomyKey: string, body: models.schemas.UpdateLevelRequest): Promise<models.schemas.MetadataTaxonomyLevels>;
     trimLevels(namespace: string, taxonomyKey: string): Promise<models.schemas.MetadataTaxonomyLevels>;
     /** Iterate every `models.schemas.MetadataTaxonomyNode` across pages, threading the marker cursor. */
     listNodes(namespace: string, taxonomyKey: string, opts?: MetadataTaxonomiesManagerListNodesOptions): AsyncIterableIterator<models.schemas.MetadataTaxonomyNode>;
     private listNodesPage;
-    createNodes(namespace: string, taxonomyKey: string, body: models.schemas.NodesCreateRequest): Promise<models.schemas.MetadataTaxonomyNode>;
+    createNodes(namespace: string, taxonomyKey: string, body: models.schemas.CreateNodesRequest): Promise<models.schemas.MetadataTaxonomyNode>;
     getNode(namespace: string, taxonomyKey: string, nodeId: string): Promise<models.schemas.MetadataTaxonomyNode>;
     deleteNode(namespace: string, taxonomyKey: string, nodeId: string): Promise<void>;
-    updateNode(namespace: string, taxonomyKey: string, nodeId: string, body: models.schemas.NodeUpdateRequest): Promise<models.schemas.MetadataTaxonomyNode>;
+    updateNode(namespace: string, taxonomyKey: string, nodeId: string, body: models.schemas.UpdateNodeRequest): Promise<models.schemas.MetadataTaxonomyNode>;
     /** Iterate every `models.schemas.MetadataTaxonomyNode` across pages, threading the marker cursor. */
     listMetadataTemplateFieldOptions(namespace: string, templateKey: string, fieldKey: string, opts?: MetadataTaxonomiesManagerListMetadataTemplateFieldOptionsOptions): AsyncIterableIterator<models.schemas.MetadataTaxonomyNode>;
     private listMetadataTemplateFieldOptionsPage;

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

@@ -22,9 +22,9 @@ export declare class MetadataTemplatesManager {
     /** Iterate every `models.schemas.MetadataTemplate` across pages, threading the marker cursor. */
     list(metadataInstanceId: string, opts?: MetadataTemplatesManagerListOptions): AsyncIterableIterator<models.schemas.MetadataTemplate>;
     private listPage;
-    getSchema(scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string): Promise<models.schemas.MetadataTemplate>;
-    updateSchema(scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string, body: Array<models.schemas.SchemaUpdateRequest>): Promise<models.schemas.MetadataTemplate>;
-    deleteSchema(scope: models.schemas.GetFileIdMetadataIdIdScope, templateKey: string): Promise<void>;
+    getSchema(scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string): Promise<models.schemas.MetadataTemplate>;
+    updateSchema(scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string, body: Array<models.schemas.UpdateSchemaRequest>): Promise<models.schemas.MetadataTemplate>;
+    deleteSchema(scope: models.schemas.GetFileIdMetadataIdScope, templateKey: string): Promise<void>;
     get(templateId: string): Promise<models.schemas.MetadataTemplate>;
     /** Iterate every `models.schemas.MetadataTemplate` across pages, threading the marker cursor. */
     listGlobal(opts?: MetadataTemplatesManagerListGlobalOptions): AsyncIterableIterator<models.schemas.MetadataTemplate>;
@@ -32,5 +32,5 @@ export declare class MetadataTemplatesManager {
     /** Iterate every `models.schemas.MetadataTemplate` across pages, threading the marker cursor. */
     listEnterprise(opts?: MetadataTemplatesManagerListEnterpriseOptions): AsyncIterableIterator<models.schemas.MetadataTemplate>;
     private listEnterprisePage;
-    createSchema(body: models.schemas.SchemaCreateRequest): Promise<models.schemas.MetadataTemplate>;
+    createSchema(body: models.schemas.CreateSchemaRequest): Promise<models.schemas.MetadataTemplate>;
 }

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

@@ -0,0 +1,9 @@
+import * as runtime from '../runtime.js';
+import type * as models from '../models/index.js';
+/** Operations for the "query" API area. */
+export declare class QueryManager {
+    private readonly session;
+    constructor(session: runtime.Client);
+    query(body: models.schemas.QueryRequestBody): Promise<models.schemas.QueryResults>;
+    queryInsights(body: models.schemas.QueryInsightsRequestBody): Promise<models.schemas.QueryInsights>;
+}

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

@@ -20,8 +20,8 @@ export declare class RetentionPoliciesManager {
     /** Iterate every `models.schemas.RetentionPolicy` across pages, threading the marker cursor. */
     list(opts?: RetentionPoliciesManagerListOptions): AsyncIterableIterator<models.schemas.RetentionPolicy>;
     private listPage;
-    create(body: models.schemas.RetentionPolicyCreateRequest): Promise<models.schemas.RetentionPolicy>;
+    create(body: models.schemas.CreateRetentionPolicyRequest): Promise<models.schemas.RetentionPolicy>;
     get(retentionPolicyId: string, opts?: RetentionPoliciesManagerGetOptions): Promise<models.schemas.RetentionPolicy>;
-    update(retentionPolicyId: string, body: models.schemas.RetentionPolicyUpdateRequest): Promise<models.schemas.RetentionPolicy>;
+    update(retentionPolicyId: string, body: models.schemas.UpdateRetentionPolicyRequest): Promise<models.schemas.RetentionPolicy>;
     delete_(retentionPolicyId: string): Promise<void>;
 }

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

@@ -28,7 +28,7 @@ export declare class RetentionPolicyAssignmentsManager {
     /** Iterate every `models.schemas.RetentionPolicyAssignment` across pages, threading the marker cursor. */
     listRetentionPolicyAssignments(retentionPolicyId: string, opts?: RetentionPolicyAssignmentsManagerListRetentionPolicyAssignmentsOptions): AsyncIterableIterator<models.schemas.RetentionPolicyAssignment>;
     private listRetentionPolicyAssignmentsPage;
-    create(body: models.schemas.RetentionPolicyAssignmentCreateRequest): Promise<models.schemas.RetentionPolicyAssignment>;
+    create(body: models.schemas.CreateRetentionPolicyAssignmentRequest): Promise<models.schemas.RetentionPolicyAssignment>;
     get(retentionPolicyAssignmentId: string, opts?: RetentionPolicyAssignmentsManagerGetOptions): Promise<models.schemas.RetentionPolicyAssignment>;
     delete_(retentionPolicyAssignmentId: string): Promise<void>;
     /** Iterate every `models.schemas.FileMini` across pages, threading the marker cursor. */

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

@@ -4,6 +4,6 @@ import type * as models from '../models/index.js';
 export declare class SessionTerminationManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createUserTerminateSessions(body: models.schemas.UserTerminateSessionsCreateRequest): Promise<models.schemas.SessionTerminationMessage>;
-    createGroupTerminateSessions(body: models.schemas.GroupTerminateSessionsCreateRequest): Promise<models.schemas.SessionTerminationMessage>;
+    createUserTerminateSessions(body: models.schemas.CreateUserTerminateSessionsRequest): Promise<models.schemas.SessionTerminationMessage>;
+    createGroupTerminateSessions(body: models.schemas.CreateGroupTerminateSessionsRequest): Promise<models.schemas.SessionTerminationMessage>;
 }