7288049459

Committed 21 Dec 2023 12:21PM UTC coverage: 37.588% (+2.7%) from 34.84%

Build # 7288049459

Build Type

Pull #45

github

Committed by

web-flow

Commit Message

Merge 56a5db1fb into 94d94c7b3

Pull Request Pull Request #45: codegen output 545b9cde35bc4f4fa9c1ac24a8dcb943

Run Details

1877 of 9030 branches covered (0.0%)

Branch coverage included in aggregate %.

1245 of 1660 new or added lines in 77 files covered. (75.0%)

78 existing lines in 23 files now uncovered.

6088 of 12160 relevant lines covered (50.07%)

75.71 hits per line

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

44.0

/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 '../auth.js';
import { NetworkSession } from '../network.js';
import { prepareParams } from '../utils.js';
import { toString } from '../utils.js';
import { ByteStream } from '../utils.js';
import { CancellationToken } from '../utils.js';
import { fetch } from '../fetch.js';
import { FetchOptions } from '../fetch.js';
import { FetchResponse } from '../fetch.js';
import { sdToJson } from '../json.js';
import { SerializedData } from '../json.js';
import { sdIsEmpty } from '../json.js';
import { sdIsBoolean } from '../json.js';
import { sdIsNumber } from '../json.js';
import { sdIsString } from '../json.js';
import { sdIsList } from '../json.js';
import { sdIsMap } from '../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: GetFolderMetadataByIdScope
): SerializedData {
  return val;
}
export function deserializeGetFolderMetadataByIdScope(
  val: any
): GetFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "GetFolderMetadataByIdScope"';
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeCreateFolderMetadataByIdScope(
  val: CreateFolderMetadataByIdScope
): SerializedData {
  return val;
}
export function deserializeCreateFolderMetadataByIdScope(
  val: any
): CreateFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "CreateFolderMetadataByIdScope"';
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeCreateFolderMetadataByIdRequestBody(
  val: CreateFolderMetadataByIdRequestBody
): SerializedData {
  return val;
}
export function deserializeCreateFolderMetadataByIdRequestBody(
  val: any
): CreateFolderMetadataByIdRequestBody {
  return val;
}
export function serializeUpdateFolderMetadataByIdScope(
  val: UpdateFolderMetadataByIdScope
): SerializedData {
  return val;
}
export function deserializeUpdateFolderMetadataByIdScope(
  val: any
): UpdateFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateFolderMetadataByIdScope"';
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateFolderMetadataByIdRequestBodyOpField(
  val: UpdateFolderMetadataByIdRequestBodyOpField
): SerializedData {
  return val;
}
export function deserializeUpdateFolderMetadataByIdRequestBodyOpField(
  val: any
): UpdateFolderMetadataByIdRequestBodyOpField {
  if (!sdIsString(val)) {
    throw '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 ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateFolderMetadataByIdRequestBody(
  val: UpdateFolderMetadataByIdRequestBody
): 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: DeleteFolderMetadataByIdScope
): SerializedData {
  return val;
}
export function deserializeDeleteFolderMetadataByIdScope(
  val: any
): DeleteFolderMetadataByIdScope {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "DeleteFolderMetadataByIdScope"';
  }
  if (val == 'global') {
    return 'global';
  }
  if (val == 'enterprise') {
    return 'enterprise';
  }
  throw ''.concat('Invalid value: ', val) as string;
}

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

box / box-typescript-sdk-gen / 7288049459

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