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

67.57

/src/managers/folderClassifications.generated.ts

import { serializeClassification } from '../schemas.generated.js';
import { deserializeClassification } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { Classification } from '../schemas.generated.js';
import { ClientError } 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 GetClassificationOnFolderHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetClassificationOnFolderHeaders, 'extraHeaders'>
      | Partial<Pick<GetClassificationOnFolderHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export interface AddClassificationToFolderRequestBody {
  readonly boxSecurityClassificationKey?: string;
}
export class AddClassificationToFolderHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<AddClassificationToFolderHeaders, 'extraHeaders'>
      | Partial<Pick<AddClassificationToFolderHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type UpdateClassificationOnFolderRequestBodyOpField = 'replace';
export type UpdateClassificationOnFolderRequestBodyPathField =
  '/Box__Security__Classification__Key';
export interface UpdateClassificationOnFolderRequestBody {
  readonly op: UpdateClassificationOnFolderRequestBodyOpField;
  readonly path: UpdateClassificationOnFolderRequestBodyPathField;
  readonly value: string;
}
export class UpdateClassificationOnFolderHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<UpdateClassificationOnFolderHeaders, 'extraHeaders'>
      | Partial<Pick<UpdateClassificationOnFolderHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class DeleteClassificationFromFolderHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<DeleteClassificationFromFolderHeaders, 'extraHeaders'>
      | Partial<Pick<DeleteClassificationFromFolderHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class FolderClassificationsManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          FolderClassificationsManager,
          | 'networkSession'
          | 'getClassificationOnFolder'
          | 'addClassificationToFolder'
          | 'updateClassificationOnFolder'
          | 'deleteClassificationFromFolder'
        >
      | Partial<Pick<FolderClassificationsManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getClassificationOnFolder(
    folderId: string,
    headers: GetClassificationOnFolderHeaders = new GetClassificationOnFolderHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<Classification> {
    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/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeClassification(response.data);
  }
  async addClassificationToFolder(
    folderId: string,
    requestBody: AddClassificationToFolderRequestBody = {} satisfies AddClassificationToFolderRequestBody,
    headers: AddClassificationToFolderHeaders = new AddClassificationToFolderHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<Classification> {
    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/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeAddClassificationToFolderRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeClassification(response.data);
  }
  async updateClassificationOnFolder(
    folderId: string,
    requestBody: readonly UpdateClassificationOnFolderRequestBody[],
    headers: UpdateClassificationOnFolderHeaders = new UpdateClassificationOnFolderHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<Classification> {
    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/enterprise/securityClassification-6VMVochwUWo'
      ) as string,
      {
        method: 'PUT',
        headers: headersMap,
        data: requestBody.map(
          serializeUpdateClassificationOnFolderRequestBody
        ) as readonly any[],
        contentType: 'application/json-patch+json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeClassification(response.data);
  }
  async deleteClassificationFromFolder(
    folderId: string,
    headers: DeleteClassificationFromFolderHeaders = new DeleteClassificationFromFolderHeaders(
      {}
    ),
    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/enterprise/securityClassification-6VMVochwUWo'
      ) 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 serializeAddClassificationToFolderRequestBody(
  val: AddClassificationToFolderRequestBody
): SerializedData {
  return {
    ['Box__Security__Classification__Key']:
      val.boxSecurityClassificationKey == void 0
        ? void 0
        : val.boxSecurityClassificationKey,
  };
}
export function deserializeAddClassificationToFolderRequestBody(
  val: any
): AddClassificationToFolderRequestBody {
  const boxSecurityClassificationKey: undefined | string =
    val.Box__Security__Classification__Key == void 0
      ? void 0
      : val.Box__Security__Classification__Key;
  return {
    boxSecurityClassificationKey: boxSecurityClassificationKey,
  } satisfies AddClassificationToFolderRequestBody;
}
export function serializeUpdateClassificationOnFolderRequestBodyOpField(
  val: UpdateClassificationOnFolderRequestBodyOpField
): SerializedData {
  return val;
}
export function deserializeUpdateClassificationOnFolderRequestBodyOpField(
  val: any
): UpdateClassificationOnFolderRequestBodyOpField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateClassificationOnFolderRequestBodyOpField"';
  }
  if (val == 'replace') {
    return 'replace';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateClassificationOnFolderRequestBodyPathField(
  val: UpdateClassificationOnFolderRequestBodyPathField
): SerializedData {
  return val;
}
export function deserializeUpdateClassificationOnFolderRequestBodyPathField(
  val: any
): UpdateClassificationOnFolderRequestBodyPathField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateClassificationOnFolderRequestBodyPathField"';
  }
  if (val == '/Box__Security__Classification__Key') {
    return '/Box__Security__Classification__Key';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateClassificationOnFolderRequestBody(
  val: UpdateClassificationOnFolderRequestBody
): SerializedData {
  return {
    ['op']: serializeUpdateClassificationOnFolderRequestBodyOpField(val.op),
    ['path']: serializeUpdateClassificationOnFolderRequestBodyPathField(
      val.path
    ),
    ['value']: val.value,
  };
}
export function deserializeUpdateClassificationOnFolderRequestBody(
  val: any
): UpdateClassificationOnFolderRequestBody {
  const op: UpdateClassificationOnFolderRequestBodyOpField =
    deserializeUpdateClassificationOnFolderRequestBodyOpField(val.op);
  const path: UpdateClassificationOnFolderRequestBodyPathField =
    deserializeUpdateClassificationOnFolderRequestBodyPathField(val.path);
  const value: string = val.value;
  return {
    op: op,
    path: path,
    value: value,
  } satisfies UpdateClassificationOnFolderRequestBody;
}

1	import { serializeClassification } from '../schemas.generated.js';
2	import { deserializeClassification } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { Classification } from '../schemas.generated.js';
6	import { ClientError } from '../schemas.generated.js';
7	import { Authentication } from '../auth.js';
8	import { NetworkSession } from '../network.js';	165✔
9	import { prepareParams } from '../utils.js';	165✔
10	import { toString } from '../utils.js';	165✔
11	import { ByteStream } from '../utils.js';
12	import { CancellationToken } from '../utils.js';
13	import { fetch } from '../fetch.js';	165✔
14	import { FetchOptions } from '../fetch.js';
15	import { FetchResponse } from '../fetch.js';
16	import { sdToJson } from '../json.js';
17	import { SerializedData } from '../json.js';
18	import { sdIsEmpty } from '../json.js';
19	import { sdIsBoolean } from '../json.js';
20	import { sdIsNumber } from '../json.js';
21	import { sdIsString } from '../json.js';	165✔
22	import { sdIsList } from '../json.js';
23	import { sdIsMap } from '../json.js';
24	export class GetClassificationOnFolderHeaders {	165✔
25	readonly extraHeaders?: {	9✔
26	readonly [key: string]: undefined \| string;
27	} = {};
28	constructor(
29	fields:
30	\| Omit<GetClassificationOnFolderHeaders, 'extraHeaders'>
31	\| Partial<Pick<GetClassificationOnFolderHeaders, 'extraHeaders'>>
32	) {
33	Object.assign(this, fields);	9✔
34	}
35	}
36	export interface AddClassificationToFolderRequestBody {
37	readonly boxSecurityClassificationKey?: string;
38	}
39	export class AddClassificationToFolderHeaders {	165✔
40	readonly extraHeaders?: {	3✔
41	readonly [key: string]: undefined \| string;
42	} = {};
43	constructor(
44	fields:
45	\| Omit<AddClassificationToFolderHeaders, 'extraHeaders'>
46	\| Partial<Pick<AddClassificationToFolderHeaders, 'extraHeaders'>>
47	) {
48	Object.assign(this, fields);	3✔
49	}
50	}
51	export type UpdateClassificationOnFolderRequestBodyOpField = 'replace';
52	export type UpdateClassificationOnFolderRequestBodyPathField =
53	'/Box__Security__Classification__Key';
54	export interface UpdateClassificationOnFolderRequestBody {
55	readonly op: UpdateClassificationOnFolderRequestBodyOpField;
56	readonly path: UpdateClassificationOnFolderRequestBodyPathField;
57	readonly value: string;
58	}
59	export class UpdateClassificationOnFolderHeaders {	165✔
60	readonly extraHeaders?: {	3✔
61	readonly [key: string]: undefined \| string;
62	} = {};
63	constructor(
64	fields:
65	\| Omit<UpdateClassificationOnFolderHeaders, 'extraHeaders'>
66	\| Partial<Pick<UpdateClassificationOnFolderHeaders, 'extraHeaders'>>
67	) {
68	Object.assign(this, fields);	3✔
69	}
70	}
71	export class DeleteClassificationFromFolderHeaders {	165✔
72	readonly extraHeaders?: {	3✔
73	readonly [key: string]: undefined \| string;
74	} = {};
75	constructor(
76	fields:
77	\| Omit<DeleteClassificationFromFolderHeaders, 'extraHeaders'>
78	\| Partial<Pick<DeleteClassificationFromFolderHeaders, 'extraHeaders'>>
79	) {
80	Object.assign(this, fields);	3✔
81	}
82	}
83	export class FolderClassificationsManager {	165✔
84	readonly auth?: Authentication;
85	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
86	constructor(
87	fields:
88	\| Omit<
89	FolderClassificationsManager,
90	\| 'networkSession'
91	\| 'getClassificationOnFolder'
92	\| 'addClassificationToFolder'
93	\| 'updateClassificationOnFolder'
94	\| 'deleteClassificationFromFolder'
95	>
96	\| Partial<Pick<FolderClassificationsManager, 'networkSession'>>
97	) {
98	Object.assign(this, fields);	285✔
99	}
100	async getClassificationOnFolder(
101	folderId: string,
102	headers: GetClassificationOnFolderHeaders = new GetClassificationOnFolderHeaders(	9✔
103	{}
104	),
105	cancellationToken?: CancellationToken
106	): Promise<Classification> {
107	const headersMap: {
108	readonly [key: string]: string;
109	} = prepareParams({ ...{}, ...headers.extraHeaders });	9✔
110	const response: FetchResponse = (await fetch(	9✔
111	''.concat(
112	this.networkSession.baseUrls.baseUrl,
113	'/folders/',
114	toString(folderId) as string,
115	'/metadata/enterprise/securityClassification-6VMVochwUWo'
116	) as string,
117	{
118	method: 'GET',
119	headers: headersMap,
120	responseFormat: 'json',
121	auth: this.auth,
122	networkSession: this.networkSession,
123	cancellationToken: cancellationToken,
124	} satisfies FetchOptions
125	)) as FetchResponse;
126	return deserializeClassification(response.data);	3✔
127	}
128	async addClassificationToFolder(
129	folderId: string,
130	requestBody: AddClassificationToFolderRequestBody = {} satisfies AddClassificationToFolderRequestBody,	×
131	headers: AddClassificationToFolderHeaders = new AddClassificationToFolderHeaders(	3✔
132	{}
133	),
134	cancellationToken?: CancellationToken
135	): Promise<Classification> {
136	const headersMap: {
137	readonly [key: string]: string;
138	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
139	const response: FetchResponse = (await fetch(	3✔
140	''.concat(
141	this.networkSession.baseUrls.baseUrl,
142	'/folders/',
143	toString(folderId) as string,
144	'/metadata/enterprise/securityClassification-6VMVochwUWo'
145	) as string,
146	{
147	method: 'POST',
148	headers: headersMap,
149	data: serializeAddClassificationToFolderRequestBody(requestBody),
150	contentType: 'application/json',
151	responseFormat: 'json',
152	auth: this.auth,
153	networkSession: this.networkSession,
154	cancellationToken: cancellationToken,
155	} satisfies FetchOptions
156	)) as FetchResponse;
157	return deserializeClassification(response.data);	3✔
158	}
159	async updateClassificationOnFolder(
160	folderId: string,
161	requestBody: readonly UpdateClassificationOnFolderRequestBody[],
162	headers: UpdateClassificationOnFolderHeaders = new UpdateClassificationOnFolderHeaders(	3✔
163	{}
164	),
165	cancellationToken?: CancellationToken
166	): Promise<Classification> {
167	const headersMap: {
168	readonly [key: string]: string;
169	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
170	const response: FetchResponse = (await fetch(	3✔
171	''.concat(
172	this.networkSession.baseUrls.baseUrl,
173	'/folders/',
174	toString(folderId) as string,
175	'/metadata/enterprise/securityClassification-6VMVochwUWo'
176	) as string,
177	{
178	method: 'PUT',
179	headers: headersMap,
180	data: requestBody.map(
181	serializeUpdateClassificationOnFolderRequestBody
182	) as readonly any[],
183	contentType: 'application/json-patch+json',
184	responseFormat: 'json',
185	auth: this.auth,
186	networkSession: this.networkSession,
187	cancellationToken: cancellationToken,
188	} satisfies FetchOptions
189	)) as FetchResponse;
190	return deserializeClassification(response.data);	3✔
191	}
192	async deleteClassificationFromFolder(
193	folderId: string,
194	headers: DeleteClassificationFromFolderHeaders = new DeleteClassificationFromFolderHeaders(	3✔
195	{}
196	),
197	cancellationToken?: CancellationToken
198	): Promise<undefined> {
199	const headersMap: {
200	readonly [key: string]: string;
201	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
202	const response: FetchResponse = (await fetch(	3✔
203	''.concat(
204	this.networkSession.baseUrls.baseUrl,
205	'/folders/',
206	toString(folderId) as string,
207	'/metadata/enterprise/securityClassification-6VMVochwUWo'
208	) as string,
209	{
210	method: 'DELETE',
211	headers: headersMap,
212	responseFormat: void 0,
213	auth: this.auth,
214	networkSession: this.networkSession,
215	cancellationToken: cancellationToken,
216	} satisfies FetchOptions
217	)) as FetchResponse;
218	return void 0;	3✔
219	}
220	}
221	export function serializeAddClassificationToFolderRequestBody(	165✔
222	val: AddClassificationToFolderRequestBody
223	): SerializedData {
224	return {	3✔
225	['Box__Security__Classification__Key']:
226	val.boxSecurityClassificationKey == void 0	3!
227	? void 0
228	: val.boxSecurityClassificationKey,
229	};
230	}
231	export function deserializeAddClassificationToFolderRequestBody(	165✔
232	val: any
233	): AddClassificationToFolderRequestBody {
234	const boxSecurityClassificationKey: undefined \| string =
235	val.Box__Security__Classification__Key == void 0	×
236	? void 0
237	: val.Box__Security__Classification__Key;
238	return {	×
239	boxSecurityClassificationKey: boxSecurityClassificationKey,
240	} satisfies AddClassificationToFolderRequestBody;
241	}
242	export function serializeUpdateClassificationOnFolderRequestBodyOpField(	165✔
243	val: UpdateClassificationOnFolderRequestBodyOpField
244	): SerializedData {
245	return val;	3✔
246	}
247	export function deserializeUpdateClassificationOnFolderRequestBodyOpField(	165✔
248	val: any
249	): UpdateClassificationOnFolderRequestBodyOpField {
250	if (!sdIsString(val)) {	×
NEW 251	throw 'Expecting a string for "UpdateClassificationOnFolderRequestBodyOpField"';	×
252	}
253	if (val == 'replace') {	×
254	return 'replace';	×
255	}
256	throw ''.concat('Invalid value: ', val) as string;	×
257	}
258	export function serializeUpdateClassificationOnFolderRequestBodyPathField(	165✔
259	val: UpdateClassificationOnFolderRequestBodyPathField
260	): SerializedData {
261	return val;	3✔
262	}
263	export function deserializeUpdateClassificationOnFolderRequestBodyPathField(	165✔
264	val: any
265	): UpdateClassificationOnFolderRequestBodyPathField {
266	if (!sdIsString(val)) {	×
NEW 267	throw 'Expecting a string for "UpdateClassificationOnFolderRequestBodyPathField"';	×
268	}
NEW 269	if (val == '/Box__Security__Classification__Key') {	×
NEW 270	return '/Box__Security__Classification__Key';	×
271	}
272	throw ''.concat('Invalid value: ', val) as string;	×
273	}
274	export function serializeUpdateClassificationOnFolderRequestBody(	165✔
275	val: UpdateClassificationOnFolderRequestBody
276	): SerializedData {
277	return {	3✔
278	['op']: serializeUpdateClassificationOnFolderRequestBodyOpField(val.op),
279	['path']: serializeUpdateClassificationOnFolderRequestBodyPathField(
280	val.path
281	),
282	['value']: val.value,
283	};
284	}
285	export function deserializeUpdateClassificationOnFolderRequestBody(	165✔
286	val: any
287	): UpdateClassificationOnFolderRequestBody {
288	const op: UpdateClassificationOnFolderRequestBodyOpField =
NEW 289	deserializeUpdateClassificationOnFolderRequestBodyOpField(val.op);	×
290	const path: UpdateClassificationOnFolderRequestBodyPathField =
NEW 291	deserializeUpdateClassificationOnFolderRequestBodyPathField(val.path);	×
NEW 292	const value: string = val.value;	×
UNCOV 293	return {	×
294	op: op,
295	path: path,
296	value: value,
297	} satisfies UpdateClassificationOnFolderRequestBody;
298	}

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