@unofficialbox/box-open-sdk 0.3.1 → 0.4.1

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

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

@@ -11,7 +11,7 @@ export declare class SharedLinksFilesManager {
     constructor(session: runtime.Client);
     getSharedItems(boxapi: string, opts?: SharedLinksFilesManagerGetSharedItemsOptions): Promise<models.schemas.FileFull>;
     getFileGetSharedLink(fileId: string, fields: string): Promise<models.schemas.FileFull>;
-    updateFileAddSharedLink(fileId: string, fields: string, body: models.schemas.FileUpdateRequest2): Promise<models.schemas.FileFull>;
-    updateFileUpdateSharedLink(fileId: string, fields: string, body: models.schemas.FileUpdateRequest2): Promise<models.schemas.FileFull>;
-    updateFileRemoveSharedLink(fileId: string, fields: string, body: models.schemas.FileUpdateRequest3): Promise<models.schemas.FileFull>;
+    updateFileAddSharedLink(fileId: string, fields: string, body: models.schemas.UpdateFileAddSharedLinkRequest): Promise<models.schemas.FileFull>;
+    updateFileUpdateSharedLink(fileId: string, fields: string, body: models.schemas.UpdateFileAddSharedLinkRequest): Promise<models.schemas.FileFull>;
+    updateFileRemoveSharedLink(fileId: string, fields: string, body: models.schemas.UpdateFileRemoveSharedLinkRequest): Promise<models.schemas.FileFull>;
 }

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

@@ -11,7 +11,7 @@ export declare class SharedLinksFoldersManager {
     constructor(session: runtime.Client);
     getSharedItemsFolders(boxapi: string, opts?: SharedLinksFoldersManagerGetSharedItemsFoldersOptions): Promise<models.schemas.FolderFull>;
     getFolderGetSharedLink(folderId: string, fields: string): Promise<models.schemas.FolderFull>;
-    updateFolderAddSharedLink(folderId: string, fields: string, body: models.schemas.FileUpdateRequest2): Promise<models.schemas.FolderFull>;
-    updateFolderUpdateSharedLink(folderId: string, fields: string, body: models.schemas.FolderUpdateRequest2): Promise<models.schemas.FolderFull>;
-    updateFolderRemoveSharedLink(folderId: string, fields: string, body: models.schemas.FileUpdateRequest3): Promise<models.schemas.FolderFull>;
+    updateFolderAddSharedLink(folderId: string, fields: string, body: models.schemas.UpdateFileAddSharedLinkRequest): Promise<models.schemas.FolderFull>;
+    updateFolderUpdateSharedLink(folderId: string, fields: string, body: models.schemas.UpdateFolderUpdateSharedLinkRequest): Promise<models.schemas.FolderFull>;
+    updateFolderRemoveSharedLink(folderId: string, fields: string, body: models.schemas.UpdateFileRemoveSharedLinkRequest): Promise<models.schemas.FolderFull>;
 }

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

@@ -11,7 +11,7 @@ export declare class SharedLinksWebLinksManager {
     constructor(session: runtime.Client);
     getSharedItemsWebLinks(boxapi: string, opts?: SharedLinksWebLinksManagerGetSharedItemsWebLinksOptions): Promise<models.schemas.WebLink>;
     getWebLinkGetSharedLink(webLinkId: string, fields: string): Promise<models.schemas.WebLink>;
-    updateWebLinkAddSharedLink(webLinkId: string, fields: string, body: models.schemas.FileUpdateRequest2): Promise<models.schemas.WebLink>;
-    updateWebLinkUpdateSharedLink(webLinkId: string, fields: string, body: models.schemas.FileUpdateRequest2): Promise<models.schemas.WebLink>;
-    updateWebLinkRemoveSharedLink(webLinkId: string, fields: string, body: models.schemas.FileUpdateRequest3): Promise<models.schemas.WebLink>;
+    updateWebLinkAddSharedLink(webLinkId: string, fields: string, body: models.schemas.UpdateFileAddSharedLinkRequest): Promise<models.schemas.WebLink>;
+    updateWebLinkUpdateSharedLink(webLinkId: string, fields: string, body: models.schemas.UpdateFileAddSharedLinkRequest): Promise<models.schemas.WebLink>;
+    updateWebLinkRemoveSharedLink(webLinkId: string, fields: string, body: models.schemas.UpdateFileRemoveSharedLinkRequest): Promise<models.schemas.WebLink>;
 }

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

@@ -14,5 +14,5 @@ export declare class ShieldInformationBarrierSegmentMembersManager {
     /** Iterate every `models.schemas.ShieldInformationBarrierSegmentMember` across pages, threading the marker cursor. */
     list(shieldInformationBarrierSegmentId: string, opts?: ShieldInformationBarrierSegmentMembersManagerListOptions): AsyncIterableIterator<models.schemas.ShieldInformationBarrierSegmentMember>;
     private listPage;
-    create(body: models.schemas.ShieldInformationBarrierSegmentMemberCreateRequest): Promise<models.schemas.ShieldInformationBarrierSegmentMember>;
+    create(body: models.schemas.CreateShieldInformationBarrierSegmentMemberRequest): Promise<models.schemas.ShieldInformationBarrierSegmentMember>;
 }

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

@@ -14,5 +14,5 @@ export declare class ShieldInformationBarrierSegmentRestrictionsManager {
     /** Iterate every `models.schemas.ShieldInformationBarrierSegmentRestriction` across pages, threading the marker cursor. */
     list(shieldInformationBarrierSegmentId: string, opts?: ShieldInformationBarrierSegmentRestrictionsManagerListOptions): AsyncIterableIterator<models.schemas.ShieldInformationBarrierSegmentRestriction>;
     private listPage;
-    create(body: models.schemas.ShieldInformationBarrierSegmentRestrictionCreateRequest): Promise<models.schemas.ShieldInformationBarrierSegmentRestriction>;
+    create(body: models.schemas.CreateShieldInformationBarrierSegmentRestrictionRequest): Promise<models.schemas.ShieldInformationBarrierSegmentRestriction>;
 }

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

@@ -10,10 +10,10 @@ export declare class ShieldInformationBarrierSegmentsManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(shieldInformationBarrierSegmentId: string): Promise<models.schemas.ShieldInformationBarrierSegment>;
-    update(shieldInformationBarrierSegmentId: string, body: models.schemas.ShieldInformationBarrierSegmentUpdateRequest): Promise<models.schemas.ShieldInformationBarrierSegment>;
+    update(shieldInformationBarrierSegmentId: string, body: models.schemas.UpdateShieldInformationBarrierSegmentRequest): Promise<models.schemas.ShieldInformationBarrierSegment>;
     delete_(shieldInformationBarrierSegmentId: string): Promise<void>;
     /** Iterate every `models.schemas.ShieldInformationBarrierSegment` across pages, threading the marker cursor. */
     list(shieldInformationBarrierId: string, opts?: ShieldInformationBarrierSegmentsManagerListOptions): AsyncIterableIterator<models.schemas.ShieldInformationBarrierSegment>;
     private listPage;
-    create(body: models.schemas.ShieldInformationBarrierSegmentCreateRequest): Promise<models.schemas.ShieldInformationBarrierSegment>;
+    create(body: models.schemas.CreateShieldInformationBarrierSegmentRequest): Promise<models.schemas.ShieldInformationBarrierSegment>;
 }

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

@@ -10,9 +10,9 @@ export declare class ShieldInformationBarriersManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(shieldInformationBarrierId: string): Promise<models.schemas.ShieldInformationBarrier>;
-    createChangeStatus(body: models.schemas.ChangeStatusCreateRequest): Promise<models.schemas.ShieldInformationBarrier>;
+    createChangeStatus(body: models.schemas.CreateChangeStatusRequest): Promise<models.schemas.ShieldInformationBarrier>;
     /** Iterate every `models.schemas.ShieldInformationBarrier` across pages, threading the marker cursor. */
     list(opts?: ShieldInformationBarriersManagerListOptions): AsyncIterableIterator<models.schemas.ShieldInformationBarrier>;
     private listPage;
-    create(body: models.schemas.ShieldInformationBarrierCreateRequest): Promise<models.schemas.ShieldInformationBarrier>;
+    create(body: models.schemas.CreateShieldInformationBarrierRequest): Promise<models.schemas.ShieldInformationBarrier>;
 }

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

@@ -5,8 +5,8 @@ export declare class SkillsManager {
     private readonly session;
     constructor(session: runtime.Client);
     get(fileId: string): Promise<models.schemas.SkillCardsMetadata>;
-    update(fileId: string, body: Array<models.schemas.SkillUpdateRequest>): Promise<models.schemas.SkillCardsMetadata>;
-    create(fileId: string, body: models.schemas.SkillCreateRequest): Promise<models.schemas.SkillCardsMetadata>;
+    update(fileId: string, body: Array<models.schemas.UpdateSkillRequest>): Promise<models.schemas.SkillCardsMetadata>;
+    create(fileId: string, body: models.schemas.CreateSkillRequest): Promise<models.schemas.SkillCardsMetadata>;
     delete_(fileId: string): Promise<void>;
-    updateSkillInvocation(skillId: string, body: models.schemas.SkillInvocationUpdateRequest): Promise<void>;
+    updateSkillInvocation(skillId: string, body: models.schemas.UpdateSkillInvocationRequest): Promise<void>;
 }

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

@@ -11,8 +11,8 @@ export declare class StoragePolicyAssignmentsManager {
     /** Iterate every `models.schemas.StoragePolicyAssignment` across pages, threading the marker cursor. */
     list(resolvedForType: models.schemas.GetResolvedForType, resolvedForId: string, opts?: StoragePolicyAssignmentsManagerListOptions): AsyncIterableIterator<models.schemas.StoragePolicyAssignment>;
     private listPage;
-    create(body: models.schemas.StoragePolicyAssignmentCreateRequest): Promise<models.schemas.StoragePolicyAssignment>;
+    create(body: models.schemas.CreateStoragePolicyAssignmentRequest): Promise<models.schemas.StoragePolicyAssignment>;
     get(storagePolicyAssignmentId: string): Promise<models.schemas.StoragePolicyAssignment>;
-    update(storagePolicyAssignmentId: string, body: models.schemas.StoragePolicyAssignmentUpdateRequest): Promise<models.schemas.StoragePolicyAssignment>;
+    update(storagePolicyAssignmentId: string, body: models.schemas.UpdateStoragePolicyAssignmentRequest): Promise<models.schemas.StoragePolicyAssignment>;
     delete_(storagePolicyAssignmentId: string): Promise<void>;
 }

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

@@ -5,8 +5,8 @@ export declare class TaskAssignmentsManager {
     private readonly session;
     constructor(session: runtime.Client);
     listTaskAssignments(taskId: string): Promise<models.schemas.TaskAssignments>;
-    create(body: models.schemas.TaskAssignmentCreateRequest): Promise<models.schemas.TaskAssignment>;
+    create(body: models.schemas.CreateTaskAssignmentRequest): Promise<models.schemas.TaskAssignment>;
     get(taskAssignmentId: string): Promise<models.schemas.TaskAssignment>;
-    update(taskAssignmentId: string, body: models.schemas.TaskAssignmentUpdateRequest): Promise<models.schemas.TaskAssignment>;
+    update(taskAssignmentId: string, body: models.schemas.UpdateTaskAssignmentRequest): Promise<models.schemas.TaskAssignment>;
     delete_(taskAssignmentId: string): Promise<void>;
 }

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

@@ -5,8 +5,8 @@ export declare class TasksManager {
     private readonly session;
     constructor(session: runtime.Client);
     listFile(fileId: string): Promise<models.schemas.Tasks>;
-    create(body: models.schemas.TaskCreateRequest): Promise<models.schemas.Task>;
+    create(body: models.schemas.CreateTaskRequest): Promise<models.schemas.Task>;
     get(taskId: string): Promise<models.schemas.Task>;
-    update(taskId: string, body: models.schemas.TaskUpdateRequest): Promise<models.schemas.Task>;
+    update(taskId: string, body: models.schemas.UpdateTaskRequest): Promise<models.schemas.Task>;
     delete_(taskId: string): Promise<void>;
 }

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

@@ -9,6 +9,6 @@ export declare class TermsOfServiceUserStatusesManager {
     private readonly session;
     constructor(session: runtime.Client);
     list(tosId: string, opts?: TermsOfServiceUserStatusesManagerListOptions): Promise<models.schemas.TermsOfServiceUserStatuses>;
-    create(body: models.schemas.TermsOfServiceUserStatuseCreateRequest): Promise<models.schemas.TermsOfServiceUserStatus>;
-    update(termsOfServiceUserStatusId: string, body: models.schemas.TermsOfServiceUserStatuseUpdateRequest): Promise<models.schemas.TermsOfServiceUserStatus>;
+    create(body: models.schemas.CreateTermsOfServiceUserStatusRequest): Promise<models.schemas.TermsOfServiceUserStatus>;
+    update(termsOfServiceUserStatusId: string, body: models.schemas.UpdateTermsOfServiceUserStatusRequest): Promise<models.schemas.TermsOfServiceUserStatus>;
 }

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

@@ -9,7 +9,7 @@ export declare class TermsOfServicesManager {
     private readonly session;
     constructor(session: runtime.Client);
     list(opts?: TermsOfServicesManagerListOptions): Promise<models.schemas.TermsOfServices>;
-    create(body: models.schemas.TermsOfServiceCreateRequest): Promise<models.schemas.TermsOfService>;
+    create(body: models.schemas.CreateTermsOfServiceRequest): Promise<models.schemas.TermsOfService>;
     get(termsOfServiceId: string): Promise<models.schemas.TermsOfService>;
-    update(termsOfServiceId: string, body: models.schemas.TermsOfServiceUpdateRequest): Promise<models.schemas.TermsOfService>;
+    update(termsOfServiceId: string, body: models.schemas.UpdateTermsOfServiceRequest): Promise<models.schemas.TermsOfService>;
 }

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

@@ -9,5 +9,5 @@ export interface TransferManagerTransferFoldersOptions {
 export declare class TransferManager {
     private readonly session;
     constructor(session: runtime.Client);
-    transferFolders(userId: string, body: models.schemas.UserFolder0UpdateRequest, opts?: TransferManagerTransferFoldersOptions): Promise<models.schemas.FolderFull>;
+    transferFolders(userId: string, body: models.schemas.TransferFoldersRequest, opts?: TransferManagerTransferFoldersOptions): Promise<models.schemas.FolderFull>;
 }

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

@@ -12,7 +12,7 @@ export interface TrashedFilesManagerGetFileTrashOptions {
 export declare class TrashedFilesManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createFile(fileId: string, body: models.schemas.FileCreateRequest, opts?: TrashedFilesManagerCreateFileOptions): Promise<models.schemas.TrashFileRestored>;
+    createFile(fileId: string, body: models.schemas.CreateFileRequest, opts?: TrashedFilesManagerCreateFileOptions): Promise<models.schemas.TrashFileRestored>;
     getFileTrash(fileId: string, opts?: TrashedFilesManagerGetFileTrashOptions): Promise<models.schemas.TrashFile>;
     deleteFileTrash(fileId: string): Promise<void>;
 }

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

@@ -12,7 +12,7 @@ export interface TrashedFoldersManagerGetFolderTrashOptions {
 export declare class TrashedFoldersManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createFolder(folderId: string, body: models.schemas.FileCreateRequest, opts?: TrashedFoldersManagerCreateFolderOptions): Promise<models.schemas.TrashFolderRestored>;
+    createFolder(folderId: string, body: models.schemas.CreateFileRequest, opts?: TrashedFoldersManagerCreateFolderOptions): Promise<models.schemas.TrashFolderRestored>;
     getFolderTrash(folderId: string, opts?: TrashedFoldersManagerGetFolderTrashOptions): Promise<models.schemas.TrashFolder>;
     deleteFolderTrash(folderId: string): Promise<void>;
 }

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

@@ -12,7 +12,7 @@ export interface TrashedWebLinksManagerGetWebLinkTrashOptions {
 export declare class TrashedWebLinksManager {
     private readonly session;
     constructor(session: runtime.Client);
-    createWebLink(webLinkId: string, body: models.schemas.FileCreateRequest, opts?: TrashedWebLinksManagerCreateWebLinkOptions): Promise<models.schemas.TrashWebLinkRestored>;
+    createWebLink(webLinkId: string, body: models.schemas.CreateFileRequest, opts?: TrashedWebLinksManagerCreateWebLinkOptions): Promise<models.schemas.TrashWebLinkRestored>;
     getWebLinkTrash(webLinkId: string, opts?: TrashedWebLinksManagerGetWebLinkTrashOptions): Promise<models.schemas.TrashWebLink>;
     deleteWebLinkTrash(webLinkId: string): Promise<void>;
 }

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

@@ -15,7 +15,7 @@ export interface UploadsManagerUploadFileOptions {
 export declare class UploadsManager {
     private readonly session;
     constructor(session: runtime.Client);
-    uploadFileVersion(fileId: string, body: models.schemas.FileIdContentCreateRequest, opts?: UploadsManagerUploadFileVersionOptions): Promise<models.schemas.Files>;
-    uploadFile(body: models.schemas.FileContentCreateRequest, opts?: UploadsManagerUploadFileOptions): Promise<models.schemas.Files>;
+    uploadFileVersion(fileId: string, body: models.schemas.CreateFileIdContentRequest, opts?: UploadsManagerUploadFileVersionOptions): Promise<models.schemas.Files>;
+    uploadFile(body: models.schemas.CreateFileContentRequest, opts?: UploadsManagerUploadFileOptions): Promise<models.schemas.Files>;
     optionFileContent(body: models.schemas.OptionFileContentRequest): Promise<models.schemas.UploadUrl>;
 }

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

@@ -14,7 +14,7 @@ export declare class UserCollaborationsManager {
     private readonly session;
     constructor(session: runtime.Client);
     getCollaboration(collaborationId: string, opts?: UserCollaborationsManagerGetCollaborationOptions): Promise<models.schemas.Collaboration>;
-    updateCollaboration(collaborationId: string, body: models.schemas.CollaborationUpdateRequest): Promise<models.schemas.Collaboration>;
+    updateCollaboration(collaborationId: string, body: models.schemas.UpdateCollaborationRequest): Promise<models.schemas.Collaboration>;
     deleteCollaboration(collaborationId: string): Promise<void>;
-    createCollaborations(body: models.schemas.CollaborationsCreateRequest, opts?: UserCollaborationsManagerCreateCollaborationsOptions): Promise<models.schemas.Collaboration>;
+    createCollaborations(body: models.schemas.CreateCollaborationsRequest, opts?: UserCollaborationsManagerCreateCollaborationsOptions): Promise<models.schemas.Collaboration>;
 }

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

@@ -39,9 +39,9 @@ export declare class UsersManager {
     /** Iterate every `models.schemas.UserFull` across pages, threading the marker cursor. */
     list(opts?: UsersManagerListOptions): AsyncIterableIterator<models.schemas.UserFull>;
     private listPage;
-    create(body: models.schemas.UserCreateRequest, opts?: UsersManagerCreateOptions): Promise<models.schemas.UserFull>;
+    create(body: models.schemas.CreateUserRequest, opts?: UsersManagerCreateOptions): Promise<models.schemas.UserFull>;
     getMe(opts?: UsersManagerGetMeOptions): Promise<models.schemas.UserFull>;
     get(userId: string, opts?: UsersManagerGetOptions): Promise<models.schemas.UserFull>;
-    update(userId: string, body: models.schemas.UserUpdateRequest, opts?: UsersManagerUpdateOptions): Promise<models.schemas.UserFull>;
+    update(userId: string, body: models.schemas.UpdateUserRequest, opts?: UsersManagerUpdateOptions): Promise<models.schemas.UserFull>;
     delete_(userId: string, opts?: UsersManagerDeleteOptions): Promise<void>;
 }

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

@@ -8,8 +8,8 @@ export interface WebLinksManagerGetOptions {
 export declare class WebLinksManager {
     private readonly session;
     constructor(session: runtime.Client);
-    create(body: models.schemas.WebLinkCreateRequest): Promise<models.schemas.WebLink>;
+    create(body: models.schemas.CreateWebLinkRequest): Promise<models.schemas.WebLink>;
     get(webLinkId: string, opts?: WebLinksManagerGetOptions): Promise<models.schemas.WebLink>;
-    update(webLinkId: string, body: models.schemas.WebLinkUpdateRequest): Promise<models.schemas.WebLink>;
+    update(webLinkId: string, body: models.schemas.UpdateWebLinkRequest): Promise<models.schemas.WebLink>;
     delete_(webLinkId: string): Promise<void>;
 }

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

@@ -12,8 +12,8 @@ export declare class WebhooksManager {
     /** Iterate every `models.schemas.WebhookMini` across pages, threading the marker cursor. */
     list(opts?: WebhooksManagerListOptions): AsyncIterableIterator<models.schemas.WebhookMini>;
     private listPage;
-    create(body: models.schemas.WebhookCreateRequest): Promise<models.schemas.Webhook>;
+    create(body: models.schemas.CreateWebhookRequest): Promise<models.schemas.Webhook>;
     get(webhookId: string): Promise<models.schemas.Webhook>;
-    update(webhookId: string, body: models.schemas.WebhookUpdateRequest): Promise<models.schemas.Webhook>;
+    update(webhookId: string, body: models.schemas.UpdateWebhookRequest): Promise<models.schemas.Webhook>;
     delete_(webhookId: string): Promise<void>;
 }

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

@@ -13,5 +13,5 @@ export declare class WorkflowsManager {
     /** Iterate every `models.schemas.Workflow` across pages, threading the marker cursor. */
     list(folderId: string, opts?: WorkflowsManagerListOptions): AsyncIterableIterator<models.schemas.Workflow>;
     private listPage;
-    start(workflowId: string, body: models.schemas.WorkflowStartRequest): Promise<void>;
+    start(workflowId: string, body: models.schemas.StartWorkflowRequest): Promise<void>;
 }