8298652836

Committed 15 Mar 2024 03:31PM UTC coverage: 43.864% (+1.9%) from 42.003%

Build # 8298652836

Build Type

Pull #97

github

Committed by

web-flow

Commit Message

Merge ef32e8277 into 14e115481

Pull Request Pull Request #97: feat: Support `additionalProperties` of type any in Python and TS (box/box-codegen#453)

Run Details

2288 of 9072 branches covered (25.22%)

Branch coverage included in aggregate %.

355 of 416 new or added lines in 17 files covered. (85.34%)

186 existing lines in 5 files now uncovered.

7226 of 12618 relevant lines covered (57.27%)

68.63 hits per line

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

46.84

/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]: any;
};
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 Object.fromEntries(
    Object.entries(val).map(([k, v]: [string, any]) => [
      k,
      (function (v: any): any {
        return v;
      })(v),
    ])
  ) as {
    readonly [key: string]: any;
  };
}
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]: any;
56	};
57	export class CreateFolderMetadataByIdHeaders {	136✔
58	readonly extraHeaders?: {	6✔
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);	6✔
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?: {	4✔
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);	4✔
106	}
107	}
108	export class FolderMetadataManager {	136✔
109	readonly auth?: Authentication;
110	readonly networkSession: NetworkSession = new NetworkSession({});	262✔
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);	262✔
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,	6✔
187	scope: CreateFolderMetadataByIdScope,
188	templateKey: string,
189	requestBody: CreateFolderMetadataByIdRequestBody,
190	headers: CreateFolderMetadataByIdHeaders = new CreateFolderMetadataByIdHeaders(	6✔
191	{}
192	),
193	cancellationToken?: CancellationToken
194	): Promise<MetadataFull> {
195	const headersMap: {
196	readonly [key: string]: string;
197	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
198	const response: FetchResponse = (await fetch(	6✔
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);	6✔
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,	4✔
261	scope: DeleteFolderMetadataByIdScope,
262	templateKey: string,
263	headers: DeleteFolderMetadataByIdHeaders = new DeleteFolderMetadataByIdHeaders(	4✔
264	{}
265	),
266	cancellationToken?: CancellationToken
267	): Promise<undefined> {
268	const headersMap: {
269	readonly [key: string]: string;
270	} = prepareParams({ ...{}, ...headers.extraHeaders });	4✔
271	const response: FetchResponse = (await fetch(	4✔
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;	4✔
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 Object.fromEntries(	6✔
341	Object.entries(val).map(([k, v]: [string, any]) => [	14✔
342	k,
343	(function (v: any): any {
344	return v;	14✔
345	})(v),
346	])
347	) as {
348	readonly [key: string]: any;
349	};
350	}
351	export function deserializeCreateFolderMetadataByIdRequestBody(	136✔
352	val: any
353	): CreateFolderMetadataByIdRequestBody {
354	return val;	×
355	}
356	export function serializeUpdateFolderMetadataByIdScope(	136✔
357	val: any
358	): SerializedData {
359	return val;	×
360	}
361	export function deserializeUpdateFolderMetadataByIdScope(	136✔
362	val: any
363	): UpdateFolderMetadataByIdScope {
364	if (!sdIsString(val)) {	×
365	throw new BoxSdkError({	×
366	message: 'Expecting a string for "UpdateFolderMetadataByIdScope"',
367	});
368	}
369	if (val == 'global') {	×
370	return 'global';	×
371	}
372	if (val == 'enterprise') {	×
373	return 'enterprise';	×
374	}
375	throw new BoxSdkError({	×
376	message: ''.concat('Invalid value: ', val) as string,
377	});
378	}
379	export function serializeUpdateFolderMetadataByIdRequestBodyOpField(	136✔
380	val: any
381	): SerializedData {
382	return val;	2✔
383	}
384	export function deserializeUpdateFolderMetadataByIdRequestBodyOpField(	136✔
385	val: any
386	): UpdateFolderMetadataByIdRequestBodyOpField {
387	if (!sdIsString(val)) {	×
388	throw new BoxSdkError({	×
389	message:
390	'Expecting a string for "UpdateFolderMetadataByIdRequestBodyOpField"',
391	});
392	}
393	if (val == 'add') {	×
394	return 'add';	×
395	}
396	if (val == 'replace') {	×
397	return 'replace';	×
398	}
399	if (val == 'remove') {	×
400	return 'remove';	×
401	}
402	if (val == 'test') {	×
403	return 'test';	×
404	}
405	if (val == 'move') {	×
406	return 'move';	×
407	}
408	if (val == 'copy') {	×
409	return 'copy';	×
410	}
411	throw new BoxSdkError({	×
412	message: ''.concat('Invalid value: ', val) as string,
413	});
414	}
415	export function serializeUpdateFolderMetadataByIdRequestBody(	136✔
416	val: any
417	): SerializedData {
418	return {	2✔
419	['op']:
420	val.op == void 0	2!
421	? void 0
422	: serializeUpdateFolderMetadataByIdRequestBodyOpField(val.op),
423	['path']: val.path == void 0 ? void 0 : val.path,	2!
424	['value']: val.value == void 0 ? void 0 : val.value,	2!
425	['from']: val.from == void 0 ? void 0 : val.from,	2!
426	};
427	}
428	export function deserializeUpdateFolderMetadataByIdRequestBody(	136✔
429	val: any
430	): UpdateFolderMetadataByIdRequestBody {
431	const op: undefined \| UpdateFolderMetadataByIdRequestBodyOpField =
432	val.op == void 0	×
433	? void 0
434	: deserializeUpdateFolderMetadataByIdRequestBodyOpField(val.op);
435	const path: undefined \| string = val.path == void 0 ? void 0 : val.path;	×
436	const value: undefined \| string = val.value == void 0 ? void 0 : val.value;	×
437	const from: undefined \| string = val.from == void 0 ? void 0 : val.from;	×
438	return {	×
439	op: op,
440	path: path,
441	value: value,
442	from: from,
443	} satisfies UpdateFolderMetadataByIdRequestBody;
444	}
445	export function serializeDeleteFolderMetadataByIdScope(	136✔
446	val: any
447	): SerializedData {
448	return val;	×
449	}
450	export function deserializeDeleteFolderMetadataByIdScope(	136✔
451	val: any
452	): DeleteFolderMetadataByIdScope {
453	if (!sdIsString(val)) {	×
454	throw new BoxSdkError({	×
455	message: 'Expecting a string for "DeleteFolderMetadataByIdScope"',
456	});
457	}
458	if (val == 'global') {	×
459	return 'global';	×
460	}
461	if (val == 'enterprise') {	×
462	return 'enterprise';	×
463	}
464	throw new BoxSdkError({	×
465	message: ''.concat('Invalid value: ', val) as string,
466	});
467	}

box / box-typescript-sdk-gen / 8298652836

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