28487081640

Committed 30 Jun 2026 12:28PM UTC coverage: 40.775% (-0.06%) from 40.831%

Build # 28487081640

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Update `.codegen.json` with commit hash of `codegen` and `openapi` spec [skip ci] (#1530)

Co-authored-by: box-sdk-build <box-sdk-build@box.com>

Coverage Stats

4956 of 21079 branches covered (23.51%)

Branch coverage included in aggregate %.

18062 of 35372 relevant lines covered (51.06%)

171.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.85

/src/managers/folderLocks.ts

import { serializeFolderLocks } from '../schemas/folderLocks';
import { deserializeFolderLocks } from '../schemas/folderLocks';
import { serializeClientError } from '../schemas/clientError';
import { deserializeClientError } from '../schemas/clientError';
import { serializeFolderLock } from '../schemas/folderLock';
import { deserializeFolderLock } from '../schemas/folderLock';
import { ResponseFormat } from '../networking/fetchOptions';
import { FolderLocks } from '../schemas/folderLocks';
import { ClientError } from '../schemas/clientError';
import { FolderLock } from '../schemas/folderLock';
import { BoxSdkError } from '../box/errors';
import { Authentication } from '../networking/auth';
import { NetworkSession } from '../networking/network';
import { FetchOptions } from '../networking/fetchOptions';
import { FetchResponse } from '../networking/fetchResponse';
import { prepareParams } from '../internal/utils';
import { toString } from '../internal/utils';
import { ByteStream } from '../internal/utils';
import { CancellationToken } from '../internal/utils';
import { sdToJson } from '../serialization/json';
import { SerializedData } from '../serialization/json';
import { sdIsEmpty } from '../serialization/json';
import { sdIsBoolean } from '../serialization/json';
import { sdIsNumber } from '../serialization/json';
import { sdIsString } from '../serialization/json';
import { sdIsList } from '../serialization/json';
import { sdIsMap } from '../serialization/json';
export class GetFolderLocksOptionals {
  readonly headers: GetFolderLocksHeaders = new GetFolderLocksHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<GetFolderLocksOptionals, 'headers' | 'cancellationToken'> &
      Partial<Pick<GetFolderLocksOptionals, 'headers' | 'cancellationToken'>>,
  ) {
    if (fields.headers !== undefined) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken !== undefined) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface GetFolderLocksOptionalsInput {
  readonly headers?: GetFolderLocksHeaders;
  readonly cancellationToken?: CancellationToken;
}
export class CreateFolderLockOptionals {
  readonly headers: CreateFolderLockHeaders = new CreateFolderLockHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<CreateFolderLockOptionals, 'headers' | 'cancellationToken'> &
      Partial<Pick<CreateFolderLockOptionals, 'headers' | 'cancellationToken'>>,
  ) {
    if (fields.headers !== undefined) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken !== undefined) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface CreateFolderLockOptionalsInput {
  readonly headers?: CreateFolderLockHeaders;
  readonly cancellationToken?: CancellationToken;
}
export class DeleteFolderLockByIdOptionals {
  readonly headers: DeleteFolderLockByIdHeaders =
    new DeleteFolderLockByIdHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      DeleteFolderLockByIdOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<DeleteFolderLockByIdOptionals, 'headers' | 'cancellationToken'>
      >,
  ) {
    if (fields.headers !== undefined) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken !== undefined) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface DeleteFolderLockByIdOptionalsInput {
  readonly headers?: DeleteFolderLockByIdHeaders;
  readonly cancellationToken?: CancellationToken;
}
export interface GetFolderLocksQueryParams {
  /**
   * The unique identifier that represent a folder.
   *
   * The ID for any folder can be determined
   * by visiting this folder in the web application
   * and copying the ID from the URL. For example,
   * for the URL `https://*.app.box.com/folder/123`
   * the `folder_id` is `123`.
   *
   * The root folder of a Box account is
   * always represented by the ID `0`. */
  readonly folderId: string;
}
export class GetFolderLocksHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetFolderLocksHeaders, 'extraHeaders'> &
      Partial<Pick<GetFolderLocksHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetFolderLocksHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  };
}
export interface CreateFolderLockRequestBodyLockedOperationsField {
  /**
   * Whether moving the folder should be locked. */
  readonly move: boolean;
  /**
   * Whether deleting the folder should be locked. */
  readonly delete: boolean;
  readonly rawData?: SerializedData;
}
export interface CreateFolderLockRequestBodyFolderField {
  /**
   * The content type the lock is being applied to. Only `folder`
   * is supported. */
  readonly type: string;
  /**
   * The ID of the folder. */
  readonly id: string;
  readonly rawData?: SerializedData;
}
export interface CreateFolderLockRequestBody {
  /**
   * The operations to lock for the folder. If `locked_operations` is
   * included in the request, both `move` and `delete` must also be
   * included and both set to `true`. */
  readonly lockedOperations?: CreateFolderLockRequestBodyLockedOperationsField;
  /**
   * The folder to apply the lock to. */
  readonly folder: CreateFolderLockRequestBodyFolderField;
  readonly rawData?: SerializedData;
}
export class CreateFolderLockHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<CreateFolderLockHeaders, 'extraHeaders'> &
      Partial<Pick<CreateFolderLockHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface CreateFolderLockHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  };
}
export class DeleteFolderLockByIdHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<DeleteFolderLockByIdHeaders, 'extraHeaders'> &
      Partial<Pick<DeleteFolderLockByIdHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface DeleteFolderLockByIdHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  };
}
export class FolderLocksManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields: Omit<
      FolderLocksManager,
      | 'networkSession'
      | 'getFolderLocks'
      | 'createFolderLock'
      | 'deleteFolderLockById'
    > &
      Partial<Pick<FolderLocksManager, 'networkSession'>>,
  ) {
    if (fields.auth !== undefined) {
      this.auth = fields.auth;
    }
    if (fields.networkSession !== undefined) {
      this.networkSession = fields.networkSession;
    }
  }
  /**
   * Retrieves folder lock details for a given folder.
   *
   * You must be authenticated as the owner or co-owner of the folder to
   * use this endpoint.
   * @param {GetFolderLocksQueryParams} queryParams Query parameters of getFolderLocks method
   * @param {GetFolderLocksOptionalsInput} optionalsInput
   * @returns {Promise<FolderLocks>}
   */
  async getFolderLocks(
    queryParams: GetFolderLocksQueryParams,
    optionalsInput: GetFolderLocksOptionalsInput = {},
  ): Promise<FolderLocks> {
    const optionals: GetFolderLocksOptionals = new GetFolderLocksOptionals({
      headers: optionalsInput.headers,
      cancellationToken: optionalsInput.cancellationToken,
    });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['folder_id']: toString(queryParams.folderId) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folder_locks',
          ) as string,
          method: 'GET',
          params: queryParamsMap,
          headers: headersMap,
          responseFormat: 'json' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return {
      ...deserializeFolderLocks(response.data!),
      rawData: response.data!,
    };
  }
  /**
   * Creates a folder lock on a folder, preventing it from being moved and/or
   * deleted.
   *
   * You must be authenticated as the owner or co-owner of the folder to
   * use this endpoint.
   * @param {CreateFolderLockRequestBody} requestBody Request body of createFolderLock method
   * @param {CreateFolderLockOptionalsInput} optionalsInput
   * @returns {Promise<FolderLock>}
   */
  async createFolderLock(
    requestBody: CreateFolderLockRequestBody,
    optionalsInput: CreateFolderLockOptionalsInput = {},
  ): Promise<FolderLock> {
    const optionals: CreateFolderLockOptionals = new CreateFolderLockOptionals({
      headers: optionalsInput.headers,
      cancellationToken: optionalsInput.cancellationToken,
    });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folder_locks',
          ) as string,
          method: 'POST',
          headers: headersMap,
          data: serializeCreateFolderLockRequestBody(requestBody),
          contentType: 'application/json',
          responseFormat: 'json' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return {
      ...deserializeFolderLock(response.data!),
      rawData: response.data!,
    };
  }
  /**
     * Deletes a folder lock on a given folder.
     *
     * You must be authenticated as the owner or co-owner of the folder to
     * use this endpoint.
     * @param {string} folderLockId The ID of the folder lock.
    Example: "12345"
     * @param {DeleteFolderLockByIdOptionalsInput} optionalsInput
     * @returns {Promise<undefined>}
     */
  async deleteFolderLockById(
    folderLockId: string,
    optionalsInput: DeleteFolderLockByIdOptionalsInput = {},
  ): Promise<undefined> {
    const optionals: DeleteFolderLockByIdOptionals =
      new DeleteFolderLockByIdOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folder_locks/',
            (toString(folderLockId) as string)!,
          ) as string,
          method: 'DELETE',
          headers: headersMap,
          responseFormat: 'no_content' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return void 0;
  }
}
export interface FolderLocksManagerInput {
  readonly auth?: Authentication;
  readonly networkSession?: NetworkSession;
}
export function serializeCreateFolderLockRequestBodyLockedOperationsField(
  val: CreateFolderLockRequestBodyLockedOperationsField,
): SerializedData {
  return { ['move']: val.move, ['delete']: val.delete };
}
export function deserializeCreateFolderLockRequestBodyLockedOperationsField(
  val: SerializedData,
): CreateFolderLockRequestBodyLockedOperationsField {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message:
        'Expecting a map for "CreateFolderLockRequestBodyLockedOperationsField"',
    });
  }
  if (val.move == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "move" of type "CreateFolderLockRequestBodyLockedOperationsField" to be defined',
    });
  }
  if (!sdIsBoolean(val.move)) {
    throw new BoxSdkError({
      message:
        'Expecting boolean for "move" of type "CreateFolderLockRequestBodyLockedOperationsField"',
    });
  }
  const move: boolean = val.move;
  if (val.delete == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "delete" of type "CreateFolderLockRequestBodyLockedOperationsField" to be defined',
    });
  }
  if (!sdIsBoolean(val.delete)) {
    throw new BoxSdkError({
      message:
        'Expecting boolean for "delete" of type "CreateFolderLockRequestBodyLockedOperationsField"',
    });
  }
  const _delete: boolean = val.delete;
  return {
    move: move,
    delete: _delete,
  } satisfies CreateFolderLockRequestBodyLockedOperationsField;
}
export function serializeCreateFolderLockRequestBodyFolderField(
  val: CreateFolderLockRequestBodyFolderField,
): SerializedData {
  return { ['type']: val.type, ['id']: val.id };
}
export function deserializeCreateFolderLockRequestBodyFolderField(
  val: SerializedData,
): CreateFolderLockRequestBodyFolderField {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message: 'Expecting a map for "CreateFolderLockRequestBodyFolderField"',
    });
  }
  if (val.type == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "type" of type "CreateFolderLockRequestBodyFolderField" to be defined',
    });
  }
  if (!sdIsString(val.type)) {
    throw new BoxSdkError({
      message:
        'Expecting string for "type" of type "CreateFolderLockRequestBodyFolderField"',
    });
  }
  const type: string = val.type;
  if (val.id == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "id" of type "CreateFolderLockRequestBodyFolderField" to be defined',
    });
  }
  if (!sdIsString(val.id)) {
    throw new BoxSdkError({
      message:
        'Expecting string for "id" of type "CreateFolderLockRequestBodyFolderField"',
    });
  }
  const id: string = val.id;
  return {
    type: type,
    id: id,
  } satisfies CreateFolderLockRequestBodyFolderField;
}
export function serializeCreateFolderLockRequestBody(
  val: CreateFolderLockRequestBody,
): SerializedData {
  return {
    ['locked_operations']:
      val.lockedOperations == void 0
        ? val.lockedOperations
        : serializeCreateFolderLockRequestBodyLockedOperationsField(
            val.lockedOperations,
          ),
    ['folder']: serializeCreateFolderLockRequestBodyFolderField(val.folder),
  };
}
export function deserializeCreateFolderLockRequestBody(
  val: SerializedData,
): CreateFolderLockRequestBody {
  if (!sdIsMap(val)) {
    throw new BoxSdkError({
      message: 'Expecting a map for "CreateFolderLockRequestBody"',
    });
  }
  const lockedOperations:
    undefined | CreateFolderLockRequestBodyLockedOperationsField =
    val.locked_operations == void 0
      ? void 0
      : deserializeCreateFolderLockRequestBodyLockedOperationsField(
          val.locked_operations,
        );
  if (val.folder == void 0) {
    throw new BoxSdkError({
      message:
        'Expecting "folder" of type "CreateFolderLockRequestBody" to be defined',
    });
  }
  const folder: CreateFolderLockRequestBodyFolderField =
    deserializeCreateFolderLockRequestBodyFolderField(val.folder);
  return {
    lockedOperations: lockedOperations,
    folder: folder,
  } satisfies CreateFolderLockRequestBody;
}

1	import { serializeFolderLocks } from '../schemas/folderLocks';
2	import { deserializeFolderLocks } from '../schemas/folderLocks';	246✔
3	import { serializeClientError } from '../schemas/clientError';
4	import { deserializeClientError } from '../schemas/clientError';
5	import { serializeFolderLock } from '../schemas/folderLock';
6	import { deserializeFolderLock } from '../schemas/folderLock';	246✔
7	import { ResponseFormat } from '../networking/fetchOptions';
8	import { FolderLocks } from '../schemas/folderLocks';
9	import { ClientError } from '../schemas/clientError';
10	import { FolderLock } from '../schemas/folderLock';
11	import { BoxSdkError } from '../box/errors';	246✔
12	import { Authentication } from '../networking/auth';
13	import { NetworkSession } from '../networking/network';	246✔
14	import { FetchOptions } from '../networking/fetchOptions';	246✔
15	import { FetchResponse } from '../networking/fetchResponse';
16	import { prepareParams } from '../internal/utils';	246✔
17	import { toString } from '../internal/utils';	246✔
18	import { ByteStream } from '../internal/utils';
19	import { CancellationToken } from '../internal/utils';
20	import { sdToJson } from '../serialization/json';
21	import { SerializedData } from '../serialization/json';
22	import { sdIsEmpty } from '../serialization/json';
23	import { sdIsBoolean } from '../serialization/json';	246✔
24	import { sdIsNumber } from '../serialization/json';
25	import { sdIsString } from '../serialization/json';	246✔
26	import { sdIsList } from '../serialization/json';
27	import { sdIsMap } from '../serialization/json';	246✔
28	export class GetFolderLocksOptionals {	246✔
29	readonly headers: GetFolderLocksHeaders = new GetFolderLocksHeaders({});	6✔
30	readonly cancellationToken?: CancellationToken = void 0;	6✔
31	constructor(
32	fields: Omit<GetFolderLocksOptionals, 'headers' \| 'cancellationToken'> &
33	Partial<Pick<GetFolderLocksOptionals, 'headers' \| 'cancellationToken'>>,
34	) {
35	if (fields.headers !== undefined) {	6!
36	this.headers = fields.headers;	×
37	}
38	if (fields.cancellationToken !== undefined) {	6!
39	this.cancellationToken = fields.cancellationToken;	×
40	}
41	}
42	}
43	export interface GetFolderLocksOptionalsInput {
44	readonly headers?: GetFolderLocksHeaders;
45	readonly cancellationToken?: CancellationToken;
46	}
47	export class CreateFolderLockOptionals {	246✔
48	readonly headers: CreateFolderLockHeaders = new CreateFolderLockHeaders({});	3✔
49	readonly cancellationToken?: CancellationToken = void 0;	3✔
50	constructor(
51	fields: Omit<CreateFolderLockOptionals, 'headers' \| 'cancellationToken'> &
52	Partial<Pick<CreateFolderLockOptionals, 'headers' \| 'cancellationToken'>>,
53	) {
54	if (fields.headers !== undefined) {	3!
55	this.headers = fields.headers;	×
56	}
57	if (fields.cancellationToken !== undefined) {	3!
58	this.cancellationToken = fields.cancellationToken;	×
59	}
60	}
61	}
62	export interface CreateFolderLockOptionalsInput {
63	readonly headers?: CreateFolderLockHeaders;
64	readonly cancellationToken?: CancellationToken;
65	}
66	export class DeleteFolderLockByIdOptionals {	246✔
67	readonly headers: DeleteFolderLockByIdHeaders =	6✔
68	new DeleteFolderLockByIdHeaders({});
69	readonly cancellationToken?: CancellationToken = void 0;	6✔
70	constructor(
71	fields: Omit<
72	DeleteFolderLockByIdOptionals,
73	'headers' \| 'cancellationToken'
74	> &
75	Partial<
76	Pick<DeleteFolderLockByIdOptionals, 'headers' \| 'cancellationToken'>
77	>,
78	) {
79	if (fields.headers !== undefined) {	6!
80	this.headers = fields.headers;	×
81	}
82	if (fields.cancellationToken !== undefined) {	6!
83	this.cancellationToken = fields.cancellationToken;	×
84	}
85	}
86	}
87	export interface DeleteFolderLockByIdOptionalsInput {
88	readonly headers?: DeleteFolderLockByIdHeaders;
89	readonly cancellationToken?: CancellationToken;
90	}
91	export interface GetFolderLocksQueryParams {
92	/**
93	* The unique identifier that represent a folder.
94	*
95	* The ID for any folder can be determined
96	* by visiting this folder in the web application
97	* and copying the ID from the URL. For example,
98	* for the URL `https://*.app.box.com/folder/123`
99	* the `folder_id` is `123`.
100	*
101	* The root folder of a Box account is
102	* always represented by the ID `0`. */
103	readonly folderId: string;
104	}
105	export class GetFolderLocksHeaders {	246✔
106	/**
107	* Extra headers that will be included in the HTTP request. */
108	readonly extraHeaders?: {	6✔
109	readonly [key: string]: undefined \| string;
110	} = {};
111	constructor(
112	fields: Omit<GetFolderLocksHeaders, 'extraHeaders'> &
113	Partial<Pick<GetFolderLocksHeaders, 'extraHeaders'>>,
114	) {
115	if (fields.extraHeaders !== undefined) {	6!
116	this.extraHeaders = fields.extraHeaders;	×
117	}
118	}
119	}
120	export interface GetFolderLocksHeadersInput {
121	/**
122	* Extra headers that will be included in the HTTP request. */
123	readonly extraHeaders?: {
124	readonly [key: string]: undefined \| string;
125	};
126	}
127	export interface CreateFolderLockRequestBodyLockedOperationsField {
128	/**
129	* Whether moving the folder should be locked. */
130	readonly move: boolean;
131	/**
132	* Whether deleting the folder should be locked. */
133	readonly delete: boolean;
134	readonly rawData?: SerializedData;
135	}
136	export interface CreateFolderLockRequestBodyFolderField {
137	/**
138	* The content type the lock is being applied to. Only `folder`
139	* is supported. */
140	readonly type: string;
141	/**
142	* The ID of the folder. */
143	readonly id: string;
144	readonly rawData?: SerializedData;
145	}
146	export interface CreateFolderLockRequestBody {
147	/**
148	* The operations to lock for the folder. If `locked_operations` is
149	* included in the request, both `move` and `delete` must also be
150	* included and both set to `true`. */
151	readonly lockedOperations?: CreateFolderLockRequestBodyLockedOperationsField;
152	/**
153	* The folder to apply the lock to. */
154	readonly folder: CreateFolderLockRequestBodyFolderField;
155	readonly rawData?: SerializedData;
156	}
157	export class CreateFolderLockHeaders {	246✔
158	/**
159	* Extra headers that will be included in the HTTP request. */
160	readonly extraHeaders?: {	3✔
161	readonly [key: string]: undefined \| string;
162	} = {};
163	constructor(
164	fields: Omit<CreateFolderLockHeaders, 'extraHeaders'> &
165	Partial<Pick<CreateFolderLockHeaders, 'extraHeaders'>>,
166	) {
167	if (fields.extraHeaders !== undefined) {	3!
168	this.extraHeaders = fields.extraHeaders;	×
169	}
170	}
171	}
172	export interface CreateFolderLockHeadersInput {
173	/**
174	* Extra headers that will be included in the HTTP request. */
175	readonly extraHeaders?: {
176	readonly [key: string]: undefined \| string;
177	};
178	}
179	export class DeleteFolderLockByIdHeaders {	246✔
180	/**
181	* Extra headers that will be included in the HTTP request. */
182	readonly extraHeaders?: {	6✔
183	readonly [key: string]: undefined \| string;
184	} = {};
185	constructor(
186	fields: Omit<DeleteFolderLockByIdHeaders, 'extraHeaders'> &
187	Partial<Pick<DeleteFolderLockByIdHeaders, 'extraHeaders'>>,
188	) {
189	if (fields.extraHeaders !== undefined) {	6!
190	this.extraHeaders = fields.extraHeaders;	×
191	}
192	}
193	}
194	export interface DeleteFolderLockByIdHeadersInput {
195	/**
196	* Extra headers that will be included in the HTTP request. */
197	readonly extraHeaders?: {
198	readonly [key: string]: undefined \| string;
199	};
200	}
201	export class FolderLocksManager {	246✔
202	readonly auth?: Authentication;
203	readonly networkSession: NetworkSession = new NetworkSession({});	522✔
204	constructor(
205	fields: Omit<
206	FolderLocksManager,
207	\| 'networkSession'
208	\| 'getFolderLocks'
209	\| 'createFolderLock'
210	\| 'deleteFolderLockById'
211	> &
212	Partial<Pick<FolderLocksManager, 'networkSession'>>,
213	) {
214	if (fields.auth !== undefined) {	522✔
215	this.auth = fields.auth;	522✔
216	}
217	if (fields.networkSession !== undefined) {	522✔
218	this.networkSession = fields.networkSession;	522✔
219	}
220	}
221	/**
222	* Retrieves folder lock details for a given folder.
223	*
224	* You must be authenticated as the owner or co-owner of the folder to
225	* use this endpoint.
226	* @param {GetFolderLocksQueryParams} queryParams Query parameters of getFolderLocks method
227	* @param {GetFolderLocksOptionalsInput} optionalsInput
228	* @returns {Promise<FolderLocks>}
229	*/
230	async getFolderLocks(
231	queryParams: GetFolderLocksQueryParams,	6✔
232	optionalsInput: GetFolderLocksOptionalsInput = {},	6✔
233	): Promise<FolderLocks> {
234	const optionals: GetFolderLocksOptionals = new GetFolderLocksOptionals({	6✔
235	headers: optionalsInput.headers,
236	cancellationToken: optionalsInput.cancellationToken,
237	});
238	const headers: any = optionals.headers;	6✔
239	const cancellationToken: any = optionals.cancellationToken;	6✔
240	const queryParamsMap: {
241	readonly [key: string]: string;
242	} = prepareParams({	6✔
243	['folder_id']: toString(queryParams.folderId) as string,
244	});
245	const headersMap: {
246	readonly [key: string]: string;
247	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
248	const response: FetchResponse =
249	await this.networkSession.networkClient.fetch(	6✔
250	new FetchOptions({
251	url: ''.concat(
252	this.networkSession.baseUrls.baseUrl,
253	'/2.0/folder_locks',
254	) as string,
255	method: 'GET',
256	params: queryParamsMap,
257	headers: headersMap,
258	responseFormat: 'json' as ResponseFormat,
259	auth: this.auth,
260	networkSession: this.networkSession,
261	cancellationToken: cancellationToken,
262	}),
263	);
264	return {	6✔
265	...deserializeFolderLocks(response.data!),
266	rawData: response.data!,
267	};
268	}
269	/**
270	* Creates a folder lock on a folder, preventing it from being moved and/or
271	* deleted.
272	*
273	* You must be authenticated as the owner or co-owner of the folder to
274	* use this endpoint.
275	* @param {CreateFolderLockRequestBody} requestBody Request body of createFolderLock method
276	* @param {CreateFolderLockOptionalsInput} optionalsInput
277	* @returns {Promise<FolderLock>}
278	*/
279	async createFolderLock(
280	requestBody: CreateFolderLockRequestBody,	3✔
281	optionalsInput: CreateFolderLockOptionalsInput = {},	3✔
282	): Promise<FolderLock> {
283	const optionals: CreateFolderLockOptionals = new CreateFolderLockOptionals({	3✔
284	headers: optionalsInput.headers,
285	cancellationToken: optionalsInput.cancellationToken,
286	});
287	const headers: any = optionals.headers;	3✔
288	const cancellationToken: any = optionals.cancellationToken;	3✔
289	const headersMap: {
290	readonly [key: string]: string;
291	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
292	const response: FetchResponse =
293	await this.networkSession.networkClient.fetch(	3✔
294	new FetchOptions({
295	url: ''.concat(
296	this.networkSession.baseUrls.baseUrl,
297	'/2.0/folder_locks',
298	) as string,
299	method: 'POST',
300	headers: headersMap,
301	data: serializeCreateFolderLockRequestBody(requestBody),
302	contentType: 'application/json',
303	responseFormat: 'json' as ResponseFormat,
304	auth: this.auth,
305	networkSession: this.networkSession,
306	cancellationToken: cancellationToken,
307	}),
308	);
309	return {	3✔
310	...deserializeFolderLock(response.data!),
311	rawData: response.data!,
312	};
313	}
314	/**
315	* Deletes a folder lock on a given folder.
316	*
317	* You must be authenticated as the owner or co-owner of the folder to
318	* use this endpoint.
319	* @param {string} folderLockId The ID of the folder lock.
320	Example: "12345"
321	* @param {DeleteFolderLockByIdOptionalsInput} optionalsInput
322	* @returns {Promise<undefined>}
323	*/
324	async deleteFolderLockById(
325	folderLockId: string,	6✔
326	optionalsInput: DeleteFolderLockByIdOptionalsInput = {},	6✔
327	): Promise<undefined> {
328	const optionals: DeleteFolderLockByIdOptionals =
329	new DeleteFolderLockByIdOptionals({	6✔
330	headers: optionalsInput.headers,
331	cancellationToken: optionalsInput.cancellationToken,
332	});
333	const headers: any = optionals.headers;	6✔
334	const cancellationToken: any = optionals.cancellationToken;	6✔
335	const headersMap: {
336	readonly [key: string]: string;
337	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
338	const response: FetchResponse =
339	await this.networkSession.networkClient.fetch(	6✔
340	new FetchOptions({
341	url: ''.concat(
342	this.networkSession.baseUrls.baseUrl,
343	'/2.0/folder_locks/',
344	(toString(folderLockId) as string)!,
345	) as string,
346	method: 'DELETE',
347	headers: headersMap,
348	responseFormat: 'no_content' as ResponseFormat,
349	auth: this.auth,
350	networkSession: this.networkSession,
351	cancellationToken: cancellationToken,
352	}),
353	);
354	return void 0;	3✔
355	}
356	}
357	export interface FolderLocksManagerInput {
358	readonly auth?: Authentication;
359	readonly networkSession?: NetworkSession;
360	}
361	export function serializeCreateFolderLockRequestBodyLockedOperationsField(	246✔
362	val: CreateFolderLockRequestBodyLockedOperationsField,
363	): SerializedData {
364	return { ['move']: val.move, ['delete']: val.delete };	3✔
365	}
366	export function deserializeCreateFolderLockRequestBodyLockedOperationsField(	246✔
367	val: SerializedData,
368	): CreateFolderLockRequestBodyLockedOperationsField {
369	if (!sdIsMap(val)) {	×
370	throw new BoxSdkError({	×
371	message:
372	'Expecting a map for "CreateFolderLockRequestBodyLockedOperationsField"',
373	});
374	}
375	if (val.move == void 0) {	×
376	throw new BoxSdkError({	×
377	message:
378	'Expecting "move" of type "CreateFolderLockRequestBodyLockedOperationsField" to be defined',
379	});
380	}
381	if (!sdIsBoolean(val.move)) {	×
382	throw new BoxSdkError({	×
383	message:
384	'Expecting boolean for "move" of type "CreateFolderLockRequestBodyLockedOperationsField"',
385	});
386	}
387	const move: boolean = val.move;	×
388	if (val.delete == void 0) {	×
389	throw new BoxSdkError({	×
390	message:
391	'Expecting "delete" of type "CreateFolderLockRequestBodyLockedOperationsField" to be defined',
392	});
393	}
394	if (!sdIsBoolean(val.delete)) {	×
395	throw new BoxSdkError({	×
396	message:
397	'Expecting boolean for "delete" of type "CreateFolderLockRequestBodyLockedOperationsField"',
398	});
399	}
400	const _delete: boolean = val.delete;	×
401	return {	×
402	move: move,
403	delete: _delete,
404	} satisfies CreateFolderLockRequestBodyLockedOperationsField;
405	}
406	export function serializeCreateFolderLockRequestBodyFolderField(	246✔
407	val: CreateFolderLockRequestBodyFolderField,
408	): SerializedData {
409	return { ['type']: val.type, ['id']: val.id };	3✔
410	}
411	export function deserializeCreateFolderLockRequestBodyFolderField(	246✔
412	val: SerializedData,
413	): CreateFolderLockRequestBodyFolderField {
414	if (!sdIsMap(val)) {	×
415	throw new BoxSdkError({	×
416	message: 'Expecting a map for "CreateFolderLockRequestBodyFolderField"',
417	});
418	}
419	if (val.type == void 0) {	×
420	throw new BoxSdkError({	×
421	message:
422	'Expecting "type" of type "CreateFolderLockRequestBodyFolderField" to be defined',
423	});
424	}
425	if (!sdIsString(val.type)) {	×
426	throw new BoxSdkError({	×
427	message:
428	'Expecting string for "type" of type "CreateFolderLockRequestBodyFolderField"',
429	});
430	}
431	const type: string = val.type;	×
432	if (val.id == void 0) {	×
433	throw new BoxSdkError({	×
434	message:
435	'Expecting "id" of type "CreateFolderLockRequestBodyFolderField" to be defined',
436	});
437	}
438	if (!sdIsString(val.id)) {	×
439	throw new BoxSdkError({	×
440	message:
441	'Expecting string for "id" of type "CreateFolderLockRequestBodyFolderField"',
442	});
443	}
444	const id: string = val.id;	×
445	return {	×
446	type: type,
447	id: id,
448	} satisfies CreateFolderLockRequestBodyFolderField;
449	}
450	export function serializeCreateFolderLockRequestBody(	246✔
451	val: CreateFolderLockRequestBody,
452	): SerializedData {
453	return {	3✔
454	['locked_operations']:
455	val.lockedOperations == void 0	3!
456	? val.lockedOperations
457	: serializeCreateFolderLockRequestBodyLockedOperationsField(
458	val.lockedOperations,
459	),
460	['folder']: serializeCreateFolderLockRequestBodyFolderField(val.folder),
461	};
462	}
463	export function deserializeCreateFolderLockRequestBody(	246✔
464	val: SerializedData,
465	): CreateFolderLockRequestBody {
466	if (!sdIsMap(val)) {	×
467	throw new BoxSdkError({	×
468	message: 'Expecting a map for "CreateFolderLockRequestBody"',
469	});
470	}
471	const lockedOperations:
472	undefined \| CreateFolderLockRequestBodyLockedOperationsField =
473	val.locked_operations == void 0	×
474	? void 0
475	: deserializeCreateFolderLockRequestBodyLockedOperationsField(
476	val.locked_operations,
477	);
478	if (val.folder == void 0) {	×
479	throw new BoxSdkError({	×
480	message:
481	'Expecting "folder" of type "CreateFolderLockRequestBody" to be defined',
482	});
483	}
484	const folder: CreateFolderLockRequestBodyFolderField =
485	deserializeCreateFolderLockRequestBodyFolderField(val.folder);	×
486	return {	×
487	lockedOperations: lockedOperations,
488	folder: folder,
489	} satisfies CreateFolderLockRequestBody;
490	}

box / box-node-sdk / 28487081640

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous