8286001390

Committed 14 Mar 2024 06:42PM UTC coverage: 43.903% (+1.9%) from 42.003%

Build # 8286001390

Build Type

Pull #90

github

Committed by

web-flow

Commit Message

Merge 85fa69f1e into 14e115481

Pull Request Pull Request #90: feat: use getDiscriminatorsForUnion in generic serialization (box/box-codegen#448)

Run Details

2293 of 9072 branches covered (25.28%)

Branch coverage included in aggregate %.

347 of 405 new or added lines in 17 files covered. (85.68%)

187 existing lines in 6 files now uncovered.

7226 of 12610 relevant lines covered (57.3%)

68.16 hits per line

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

46.15

/src/managers/folderMetadata.generated.ts

import { serializeMetadatas } from '../schemas.generated.js';
import { deserializeMetadatas } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { serializeMetadataFull } from '../schemas.generated.js';
import { deserializeMetadataFull } from '../schemas.generated.js';
import { Metadatas } from '../schemas.generated.js';
import { ClientError } from '../schemas.generated.js';
import { MetadataFull } from '../schemas.generated.js';
import { Authentication } from '../networking/auth.generated.js';
import { NetworkSession } from '../networking/network.generated.js';
import { prepareParams } from '../internal/utils.js';
import { toString } from '../internal/utils.js';
import { ByteStream } from '../internal/utils.js';
import { CancellationToken } from '../internal/utils.js';
import { FetchOptions } from '../networking/fetch.js';
import { FetchResponse } from '../networking/fetch.js';
import { fetch } from '../networking/fetch.js';
import { sdToJson } from '../serialization/json.js';
import { SerializedData } from '../serialization/json.js';
import { BoxSdkError } from '../box/errors.js';
import { sdIsEmpty } from '../serialization/json.js';
import { sdIsBoolean } from '../serialization/json.js';
import { sdIsNumber } from '../serialization/json.js';
import { sdIsString } from '../serialization/json.js';
import { sdIsList } from '../serialization/json.js';
import { sdIsMap } from '../serialization/json.js';
export class GetFolderMetadataHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetFolderMetadataHeaders, 'extraHeaders'>
      | Partial<Pick<GetFolderMetadataHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type GetFolderMetadataByIdScope = 'global' | 'enterprise';
export class GetFolderMetadataByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetFolderMetadataByIdHeaders, 'extraHeaders'>
      | Partial<Pick<GetFolderMetadataByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type CreateFolderMetadataByIdScope = 'global' | 'enterprise';
export type CreateFolderMetadataByIdRequestBody = {
  readonly [key: string]: string;
};
export class CreateFolderMetadataByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<CreateFolderMetadataByIdHeaders, 'extraHeaders'>
      | Partial<Pick<CreateFolderMetadataByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type UpdateFolderMetadataByIdScope = 'global' | 'enterprise';
export type UpdateFolderMetadataByIdRequestBodyOpField =
  | 'add'
  | 'replace'
  | 'remove'
  | 'test'
  | 'move'
  | 'copy';
export interface UpdateFolderMetadataByIdRequestBody {
  readonly op?: UpdateFolderMetadataByIdRequestBodyOpField;
  readonly path?: string;
  readonly value?: string;
  readonly from?: string;
}
export class UpdateFolderMetadataByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<UpdateFolderMetadataByIdHeaders, 'extraHeaders'>
      | Partial<Pick<UpdateFolderMetadataByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type DeleteFolderMetadataByIdScope = 'global' | 'enterprise';
export class DeleteFolderMetadataByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<DeleteFolderMetadataByIdHeaders, 'extraHeaders'>
      | Partial<Pick<DeleteFolderMetadataByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class FolderMetadataManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          FolderMetadataManager,
          | 'networkSession'
          | 'getFolderMetadata'
          | 'getFolderMetadataById'
          | 'createFolderMetadataById'
          | 'updateFolderMetadataById'
          | 'deleteFolderMetadataById'
        >
      | Partial<Pick<FolderMetadataManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getFolderMetadata(
    folderId: string,
    headers: GetFolderMetadataHeaders = new GetFolderMetadataHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<Metadatas> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folders/',
        toString(folderId) as string,
        '/metadata'
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeMetadatas(response.data);
  }
  async getFolderMetadataById(
    folderId: string,
    scope: GetFolderMetadataByIdScope,
    templateKey: string,
    headers: GetFolderMetadataByIdHeaders = new GetFolderMetadataByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<MetadataFull> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folders/',
        toString(folderId) as string,
        '/metadata/',
        toString(scope) as string,
        '/',
        toString(templateKey) as string
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeMetadataFull(response.data);
  }
  async createFolderMetadataById(
    folderId: string,
    scope: CreateFolderMetadataByIdScope,
    templateKey: string,
    requestBody: CreateFolderMetadataByIdRequestBody,
    headers: CreateFolderMetadataByIdHeaders = new CreateFolderMetadataByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<MetadataFull> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folders/',
        toString(folderId) as string,
        '/metadata/',
        toString(scope) as string,
        '/',
        toString(templateKey) as string
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeCreateFolderMetadataByIdRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeMetadataFull(response.data);
  }
  async updateFolderMetadataById(
    folderId: string,
    scope: UpdateFolderMetadataByIdScope,
    templateKey: string,
    requestBody: readonly UpdateFolderMetadataByIdRequestBody[],
    headers: UpdateFolderMetadataByIdHeaders = new UpdateFolderMetadataByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<MetadataFull> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folders/',
        toString(folderId) as string,
        '/metadata/',
        toString(scope) as string,
        '/',
        toString(templateKey) as string
      ) as string,
      {
        method: 'PUT',
        headers: headersMap,
        data: requestBody.map(
          serializeUpdateFolderMetadataByIdRequestBody
        ) as readonly any[],
        contentType: 'application/json-patch+json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeMetadataFull(response.data);
  }
  async deleteFolderMetadataById(
    folderId: string,
    scope: DeleteFolderMetadataByIdScope,
    templateKey: string,
    headers: DeleteFolderMetadataByIdHeaders = new DeleteFolderMetadataByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<undefined> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folders/',
        toString(folderId) as string,
        '/metadata/',
        toString(scope) as string,
        '/',
        toString(templateKey) as string
      ) as string,
      {
        method: 'DELETE',
        headers: headersMap,
        responseFormat: void 0,
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return void 0;
  }
}
export function serializeGetFolderMetadataByIdScope(val: any): SerializedData {
  return val;
}
export function deserializeGetFolderMetadataByIdScope(
  val: any
): GetFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw new BoxSdkError({
      message: 'Expecting a string for "GetFolderMetadataByIdScope"',
    });
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw new BoxSdkError({
    message: ''.concat('Invalid value: ', val) as string,
  });
}
export function serializeCreateFolderMetadataByIdScope(
  val: any
): SerializedData {
  return val;
}
export function deserializeCreateFolderMetadataByIdScope(
  val: any
): CreateFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw new BoxSdkError({
      message: 'Expecting a string for "CreateFolderMetadataByIdScope"',
    });
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw new BoxSdkError({
    message: ''.concat('Invalid value: ', val) as string,
  });
}
export function serializeCreateFolderMetadataByIdRequestBody(
  val: any
): SerializedData {
  return val;
}
export function deserializeCreateFolderMetadataByIdRequestBody(
  val: any
): CreateFolderMetadataByIdRequestBody {
  return val;
}
export function serializeUpdateFolderMetadataByIdScope(
  val: any
): SerializedData {
  return val;
}
export function deserializeUpdateFolderMetadataByIdScope(
  val: any
): UpdateFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw new BoxSdkError({
      message: 'Expecting a string for "UpdateFolderMetadataByIdScope"',
    });
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw new BoxSdkError({
    message: ''.concat('Invalid value: ', val) as string,
  });
}
export function serializeUpdateFolderMetadataByIdRequestBodyOpField(
  val: any
): SerializedData {
  return val;
}
export function deserializeUpdateFolderMetadataByIdRequestBodyOpField(
  val: any
): UpdateFolderMetadataByIdRequestBodyOpField {
  if (!sdIsString(val)) {
    throw new BoxSdkError({
      message:
        'Expecting a string for "UpdateFolderMetadataByIdRequestBodyOpField"',
    });
  }
  if (val == 'add') {
    return 'add';
  }
  if (val == 'replace') {
    return 'replace';
  }
  if (val == 'remove') {
    return 'remove';
  }
  if (val == 'test') {
    return 'test';
  }
  if (val == 'move') {
    return 'move';
  }
  if (val == 'copy') {
    return 'copy';
  }
  throw new BoxSdkError({
    message: ''.concat('Invalid value: ', val) as string,
  });
}
export function serializeUpdateFolderMetadataByIdRequestBody(
  val: any
): SerializedData {
  return {
    ['op']:
      val.op == void 0
        ? void 0
        : serializeUpdateFolderMetadataByIdRequestBodyOpField(val.op),
    ['path']: val.path == void 0 ? void 0 : val.path,
    ['value']: val.value == void 0 ? void 0 : val.value,
    ['from']: val.from == void 0 ? void 0 : val.from,
  };
}
export function deserializeUpdateFolderMetadataByIdRequestBody(
  val: any
): UpdateFolderMetadataByIdRequestBody {
  const op: undefined | UpdateFolderMetadataByIdRequestBodyOpField =
    val.op == void 0
      ? void 0
      : deserializeUpdateFolderMetadataByIdRequestBodyOpField(val.op);
  const path: undefined | string = val.path == void 0 ? void 0 : val.path;
  const value: undefined | string = val.value == void 0 ? void 0 : val.value;
  const from: undefined | string = val.from == void 0 ? void 0 : val.from;
  return {
    op: op,
    path: path,
    value: value,
    from: from,
  } satisfies UpdateFolderMetadataByIdRequestBody;
}
export function serializeDeleteFolderMetadataByIdScope(
  val: any
): SerializedData {
  return val;
}
export function deserializeDeleteFolderMetadataByIdScope(
  val: any
): DeleteFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw new BoxSdkError({
      message: 'Expecting a string for "DeleteFolderMetadataByIdScope"',
    });
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw new BoxSdkError({
    message: ''.concat('Invalid value: ', val) as string,
  });
}

1	import { serializeMetadatas } from '../schemas.generated.js';
2	import { deserializeMetadatas } from '../schemas.generated.js';	136✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { serializeMetadataFull } from '../schemas.generated.js';
6	import { deserializeMetadataFull } from '../schemas.generated.js';	136✔
7	import { Metadatas } from '../schemas.generated.js';
8	import { ClientError } from '../schemas.generated.js';
9	import { MetadataFull } from '../schemas.generated.js';
10	import { Authentication } from '../networking/auth.generated.js';
11	import { NetworkSession } from '../networking/network.generated.js';	136✔
12	import { prepareParams } from '../internal/utils.js';	136✔
13	import { toString } from '../internal/utils.js';	136✔
14	import { ByteStream } from '../internal/utils.js';
15	import { CancellationToken } from '../internal/utils.js';
16	import { FetchOptions } from '../networking/fetch.js';
17	import { FetchResponse } from '../networking/fetch.js';
18	import { fetch } from '../networking/fetch.js';	136✔
19	import { sdToJson } from '../serialization/json.js';
20	import { SerializedData } from '../serialization/json.js';
21	import { BoxSdkError } from '../box/errors.js';	136✔
22	import { sdIsEmpty } from '../serialization/json.js';
23	import { sdIsBoolean } from '../serialization/json.js';
24	import { sdIsNumber } from '../serialization/json.js';
25	import { sdIsString } from '../serialization/json.js';	136✔
26	import { sdIsList } from '../serialization/json.js';
27	import { sdIsMap } from '../serialization/json.js';
28	export class GetFolderMetadataHeaders {	136✔
29	readonly extraHeaders?: {	2✔
30	readonly [key: string]: undefined \| string;
31	} = {};
32	constructor(
33	fields:
34	\| Omit<GetFolderMetadataHeaders, 'extraHeaders'>
35	\| Partial<Pick<GetFolderMetadataHeaders, 'extraHeaders'>>
36	) {
37	Object.assign(this, fields);	2✔
38	}
39	}
40	export type GetFolderMetadataByIdScope = 'global' \| 'enterprise';
41	export class GetFolderMetadataByIdHeaders {	136✔
42	readonly extraHeaders?: {	6✔
43	readonly [key: string]: undefined \| string;
44	} = {};
45	constructor(
46	fields:
47	\| Omit<GetFolderMetadataByIdHeaders, 'extraHeaders'>
48	\| Partial<Pick<GetFolderMetadataByIdHeaders, 'extraHeaders'>>
49	) {
50	Object.assign(this, fields);	6✔
51	}
52	}
53	export type CreateFolderMetadataByIdScope = 'global' \| 'enterprise';
54	export type CreateFolderMetadataByIdRequestBody = {
55	readonly [key: string]: string;
56	};
57	export class CreateFolderMetadataByIdHeaders {	136✔
58	readonly extraHeaders?: {	4✔
59	readonly [key: string]: undefined \| string;
60	} = {};
61	constructor(
62	fields:
63	\| Omit<CreateFolderMetadataByIdHeaders, 'extraHeaders'>
64	\| Partial<Pick<CreateFolderMetadataByIdHeaders, 'extraHeaders'>>
65	) {
66	Object.assign(this, fields);	4✔
67	}
68	}
69	export type UpdateFolderMetadataByIdScope = 'global' \| 'enterprise';
70	export type UpdateFolderMetadataByIdRequestBodyOpField =
71	\| 'add'
72	\| 'replace'
73	\| 'remove'
74	\| 'test'
75	\| 'move'
76	\| 'copy';
77	export interface UpdateFolderMetadataByIdRequestBody {
78	readonly op?: UpdateFolderMetadataByIdRequestBodyOpField;
79	readonly path?: string;
80	readonly value?: string;
81	readonly from?: string;
82	}
83	export class UpdateFolderMetadataByIdHeaders {	136✔
84	readonly extraHeaders?: {	2✔
85	readonly [key: string]: undefined \| string;
86	} = {};
87	constructor(
88	fields:
89	\| Omit<UpdateFolderMetadataByIdHeaders, 'extraHeaders'>
90	\| Partial<Pick<UpdateFolderMetadataByIdHeaders, 'extraHeaders'>>
91	) {
92	Object.assign(this, fields);	2✔
93	}
94	}
95	export type DeleteFolderMetadataByIdScope = 'global' \| 'enterprise';
96	export class DeleteFolderMetadataByIdHeaders {	136✔
97	readonly extraHeaders?: {	2✔
98	readonly [key: string]: undefined \| string;
99	} = {};
100	constructor(
101	fields:
102	\| Omit<DeleteFolderMetadataByIdHeaders, 'extraHeaders'>
103	\| Partial<Pick<DeleteFolderMetadataByIdHeaders, 'extraHeaders'>>
104	) {
105	Object.assign(this, fields);	2✔
106	}
107	}
108	export class FolderMetadataManager {	136✔
109	readonly auth?: Authentication;
110	readonly networkSession: NetworkSession = new NetworkSession({});	258✔
111	constructor(
112	fields:
113	\| Omit<
114	FolderMetadataManager,
115	\| 'networkSession'
116	\| 'getFolderMetadata'
117	\| 'getFolderMetadataById'
118	\| 'createFolderMetadataById'
119	\| 'updateFolderMetadataById'
120	\| 'deleteFolderMetadataById'
121	>
122	\| Partial<Pick<FolderMetadataManager, 'networkSession'>>
123	) {
124	Object.assign(this, fields);	258✔
125	}
126	async getFolderMetadata(
127	folderId: string,	2✔
128	headers: GetFolderMetadataHeaders = new GetFolderMetadataHeaders({}),	2✔
129	cancellationToken?: CancellationToken
130	): Promise<Metadatas> {
131	const headersMap: {
132	readonly [key: string]: string;
133	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
134	const response: FetchResponse = (await fetch(	2✔
135	''.concat(
136	this.networkSession.baseUrls.baseUrl,
137	'/folders/',
138	toString(folderId) as string,
139	'/metadata'
140	) as string,
141	{
142	method: 'GET',
143	headers: headersMap,
144	responseFormat: 'json',
145	auth: this.auth,
146	networkSession: this.networkSession,
147	cancellationToken: cancellationToken,
148	} satisfies FetchOptions
149	)) as FetchResponse;
150	return deserializeMetadatas(response.data);	2✔
151	}
152	async getFolderMetadataById(
153	folderId: string,	6✔
154	scope: GetFolderMetadataByIdScope,
155	templateKey: string,
156	headers: GetFolderMetadataByIdHeaders = new GetFolderMetadataByIdHeaders(	6✔
157	{}
158	),
159	cancellationToken?: CancellationToken
160	): Promise<MetadataFull> {
161	const headersMap: {
162	readonly [key: string]: string;
163	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
164	const response: FetchResponse = (await fetch(	6✔
165	''.concat(
166	this.networkSession.baseUrls.baseUrl,
167	'/folders/',
168	toString(folderId) as string,
169	'/metadata/',
170	toString(scope) as string,
171	'/',
172	toString(templateKey) as string
173	) as string,
174	{
175	method: 'GET',
176	headers: headersMap,
177	responseFormat: 'json',
178	auth: this.auth,
179	networkSession: this.networkSession,
180	cancellationToken: cancellationToken,
181	} satisfies FetchOptions
182	)) as FetchResponse;
183	return deserializeMetadataFull(response.data);	4✔
184	}
185	async createFolderMetadataById(
186	folderId: string,	4✔
187	scope: CreateFolderMetadataByIdScope,
188	templateKey: string,
189	requestBody: CreateFolderMetadataByIdRequestBody,
190	headers: CreateFolderMetadataByIdHeaders = new CreateFolderMetadataByIdHeaders(	4✔
191	{}
192	),
193	cancellationToken?: CancellationToken
194	): Promise<MetadataFull> {
195	const headersMap: {
196	readonly [key: string]: string;
197	} = prepareParams({ ...{}, ...headers.extraHeaders });	4✔
198	const response: FetchResponse = (await fetch(	4✔
199	''.concat(
200	this.networkSession.baseUrls.baseUrl,
201	'/folders/',
202	toString(folderId) as string,
203	'/metadata/',
204	toString(scope) as string,
205	'/',
206	toString(templateKey) as string
207	) as string,
208	{
209	method: 'POST',
210	headers: headersMap,
211	data: serializeCreateFolderMetadataByIdRequestBody(requestBody),
212	contentType: 'application/json',
213	responseFormat: 'json',
214	auth: this.auth,
215	networkSession: this.networkSession,
216	cancellationToken: cancellationToken,
217	} satisfies FetchOptions
218	)) as FetchResponse;
219	return deserializeMetadataFull(response.data);	4✔
220	}
221	async updateFolderMetadataById(
222	folderId: string,	2✔
223	scope: UpdateFolderMetadataByIdScope,
224	templateKey: string,
225	requestBody: readonly UpdateFolderMetadataByIdRequestBody[],
226	headers: UpdateFolderMetadataByIdHeaders = new UpdateFolderMetadataByIdHeaders(	2✔
227	{}
228	),
229	cancellationToken?: CancellationToken
230	): Promise<MetadataFull> {
231	const headersMap: {
232	readonly [key: string]: string;
233	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
234	const response: FetchResponse = (await fetch(	2✔
235	''.concat(
236	this.networkSession.baseUrls.baseUrl,
237	'/folders/',
238	toString(folderId) as string,
239	'/metadata/',
240	toString(scope) as string,
241	'/',
242	toString(templateKey) as string
243	) as string,
244	{
245	method: 'PUT',
246	headers: headersMap,
247	data: requestBody.map(
248	serializeUpdateFolderMetadataByIdRequestBody
249	) as readonly any[],
250	contentType: 'application/json-patch+json',
251	responseFormat: 'json',
252	auth: this.auth,
253	networkSession: this.networkSession,
254	cancellationToken: cancellationToken,
255	} satisfies FetchOptions
256	)) as FetchResponse;
257	return deserializeMetadataFull(response.data);	2✔
258	}
259	async deleteFolderMetadataById(
260	folderId: string,	2✔
261	scope: DeleteFolderMetadataByIdScope,
262	templateKey: string,
263	headers: DeleteFolderMetadataByIdHeaders = new DeleteFolderMetadataByIdHeaders(	2✔
264	{}
265	),
266	cancellationToken?: CancellationToken
267	): Promise<undefined> {
268	const headersMap: {
269	readonly [key: string]: string;
270	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
271	const response: FetchResponse = (await fetch(	2✔
272	''.concat(
273	this.networkSession.baseUrls.baseUrl,
274	'/folders/',
275	toString(folderId) as string,
276	'/metadata/',
277	toString(scope) as string,
278	'/',
279	toString(templateKey) as string
280	) as string,
281	{
282	method: 'DELETE',
283	headers: headersMap,
284	responseFormat: void 0,
285	auth: this.auth,
286	networkSession: this.networkSession,
287	cancellationToken: cancellationToken,
288	} satisfies FetchOptions
289	)) as FetchResponse;
290	return void 0;	2✔
291	}
292	}
293	export function serializeGetFolderMetadataByIdScope(val: any): SerializedData {	136✔
UNCOV 294	return val;	×
295	}
296	export function deserializeGetFolderMetadataByIdScope(	136✔
297	val: any
298	): GetFolderMetadataByIdScope {
299	if (!sdIsString(val)) {	×
300	throw new BoxSdkError({	×
301	message: 'Expecting a string for "GetFolderMetadataByIdScope"',
302	});
303	}
304	if (val == 'global') {	×
305	return 'global';	×
306	}
307	if (val == 'enterprise') {	×
308	return 'enterprise';	×
309	}
310	throw new BoxSdkError({	×
311	message: ''.concat('Invalid value: ', val) as string,
312	});
313	}
314	export function serializeCreateFolderMetadataByIdScope(	136✔
315	val: any
316	): SerializedData {
317	return val;	×
318	}
319	export function deserializeCreateFolderMetadataByIdScope(	136✔
320	val: any
321	): CreateFolderMetadataByIdScope {
322	if (!sdIsString(val)) {	×
323	throw new BoxSdkError({	×
324	message: 'Expecting a string for "CreateFolderMetadataByIdScope"',
325	});
326	}
327	if (val == 'global') {	×
328	return 'global';	×
329	}
330	if (val == 'enterprise') {	×
331	return 'enterprise';	×
332	}
333	throw new BoxSdkError({	×
334	message: ''.concat('Invalid value: ', val) as string,
335	});
336	}
337	export function serializeCreateFolderMetadataByIdRequestBody(	136✔
338	val: any
339	): SerializedData {
340	return val;	4✔
341	}
342	export function deserializeCreateFolderMetadataByIdRequestBody(	136✔
343	val: any
344	): CreateFolderMetadataByIdRequestBody {
345	return val;	×
346	}
347	export function serializeUpdateFolderMetadataByIdScope(	136✔
348	val: any
349	): SerializedData {
350	return val;	×
351	}
352	export function deserializeUpdateFolderMetadataByIdScope(	136✔
353	val: any
354	): UpdateFolderMetadataByIdScope {
355	if (!sdIsString(val)) {	×
356	throw new BoxSdkError({	×
357	message: 'Expecting a string for "UpdateFolderMetadataByIdScope"',
358	});
359	}
360	if (val == 'global') {	×
361	return 'global';	×
362	}
363	if (val == 'enterprise') {	×
364	return 'enterprise';	×
365	}
366	throw new BoxSdkError({	×
367	message: ''.concat('Invalid value: ', val) as string,
368	});
369	}
370	export function serializeUpdateFolderMetadataByIdRequestBodyOpField(	136✔
371	val: any
372	): SerializedData {
373	return val;	2✔
374	}
375	export function deserializeUpdateFolderMetadataByIdRequestBodyOpField(	136✔
376	val: any
377	): UpdateFolderMetadataByIdRequestBodyOpField {
378	if (!sdIsString(val)) {	×
379	throw new BoxSdkError({	×
380	message:
381	'Expecting a string for "UpdateFolderMetadataByIdRequestBodyOpField"',
382	});
383	}
384	if (val == 'add') {	×
385	return 'add';	×
386	}
387	if (val == 'replace') {	×
388	return 'replace';	×
389	}
390	if (val == 'remove') {	×
391	return 'remove';	×
392	}
393	if (val == 'test') {	×
394	return 'test';	×
395	}
396	if (val == 'move') {	×
397	return 'move';	×
398	}
399	if (val == 'copy') {	×
400	return 'copy';	×
401	}
402	throw new BoxSdkError({	×
403	message: ''.concat('Invalid value: ', val) as string,
404	});
405	}
406	export function serializeUpdateFolderMetadataByIdRequestBody(	136✔
407	val: any
408	): SerializedData {
409	return {	2✔
410	['op']:
411	val.op == void 0	2!
412	? void 0
413	: serializeUpdateFolderMetadataByIdRequestBodyOpField(val.op),
414	['path']: val.path == void 0 ? void 0 : val.path,	2!
415	['value']: val.value == void 0 ? void 0 : val.value,	2!
416	['from']: val.from == void 0 ? void 0 : val.from,	2!
417	};
418	}
419	export function deserializeUpdateFolderMetadataByIdRequestBody(	136✔
420	val: any
421	): UpdateFolderMetadataByIdRequestBody {
422	const op: undefined \| UpdateFolderMetadataByIdRequestBodyOpField =
423	val.op == void 0	×
424	? void 0
425	: deserializeUpdateFolderMetadataByIdRequestBodyOpField(val.op);
426	const path: undefined \| string = val.path == void 0 ? void 0 : val.path;	×
427	const value: undefined \| string = val.value == void 0 ? void 0 : val.value;	×
428	const from: undefined \| string = val.from == void 0 ? void 0 : val.from;	×
429	return {	×
430	op: op,
431	path: path,
432	value: value,
433	from: from,
434	} satisfies UpdateFolderMetadataByIdRequestBody;
435	}
436	export function serializeDeleteFolderMetadataByIdScope(	136✔
437	val: any
438	): SerializedData {
439	return val;	×
440	}
441	export function deserializeDeleteFolderMetadataByIdScope(	136✔
442	val: any
443	): DeleteFolderMetadataByIdScope {
444	if (!sdIsString(val)) {	×
445	throw new BoxSdkError({	×
446	message: 'Expecting a string for "DeleteFolderMetadataByIdScope"',
447	});
448	}
449	if (val == 'global') {	×
450	return 'global';	×
451	}
452	if (val == 'enterprise') {	×
453	return 'enterprise';	×
454	}
455	throw new BoxSdkError({	×
456	message: ''.concat('Invalid value: ', val) as string,
457	});
458	}

box / box-typescript-sdk-gen / 8286001390

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