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

77.36

/src/managers/folderLocks.generated.ts

import { serializeFolderLocks } from '../schemas.generated.js';
import { deserializeFolderLocks } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { serializeFolderLock } from '../schemas.generated.js';
import { deserializeFolderLock } from '../schemas.generated.js';
import { FolderLocks } from '../schemas.generated.js';
import { ClientError } from '../schemas.generated.js';
import { FolderLock } 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 { sdToJson } from '../json.js';
import { fetch } from '../fetch.js';
import { FetchOptions } from '../fetch.js';
import { FetchResponse } from '../fetch.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 interface GetFolderLocksQueryParams {
  readonly folderId: string;
}
export class GetFolderLocksHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetFolderLocksHeaders, 'extraHeaders'>
      | Partial<Pick<GetFolderLocksHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export interface CreateFolderLockRequestBodyLockedOperationsField {
  readonly move: boolean;
  readonly delete: boolean;
}
export interface CreateFolderLockRequestBodyFolderField {
  readonly type: string;
  readonly id: string;
}
export interface CreateFolderLockRequestBody {
  readonly lockedOperations?: CreateFolderLockRequestBodyLockedOperationsField;
  readonly folder: CreateFolderLockRequestBodyFolderField;
}
export class CreateFolderLockHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<CreateFolderLockHeaders, 'extraHeaders'>
      | Partial<Pick<CreateFolderLockHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class DeleteFolderLockByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<DeleteFolderLockByIdHeaders, 'extraHeaders'>
      | Partial<Pick<DeleteFolderLockByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class FolderLocksManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          FolderLocksManager,
          | 'networkSession'
          | 'getFolderLocks'
          | 'createFolderLock'
          | 'deleteFolderLockById'
        >
      | Partial<Pick<FolderLocksManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getFolderLocks(
    queryParams: GetFolderLocksQueryParams,
    headers: GetFolderLocksHeaders = new GetFolderLocksHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<FolderLocks> {
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['folder_id']: toString(queryParams.folderId) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folder_locks'
      ) as string,
      {
        method: 'GET',
        params: queryParamsMap,
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeFolderLocks(response.data);
  }
  async createFolderLock(
    requestBody: CreateFolderLockRequestBody,
    headers: CreateFolderLockHeaders = new CreateFolderLockHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<FolderLock> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folder_locks'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeCreateFolderLockRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeFolderLock(response.data);
  }
  async deleteFolderLockById(
    folderLockId: string,
    headers: DeleteFolderLockByIdHeaders = new DeleteFolderLockByIdHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<undefined> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/folder_locks/',
        toString(folderLockId) 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 serializeCreateFolderLockRequestBodyLockedOperationsField(
  val: CreateFolderLockRequestBodyLockedOperationsField
): SerializedData {
  return { ['move']: val.move, ['delete']: val.delete };
}
export function deserializeCreateFolderLockRequestBodyLockedOperationsField(
  val: any
): CreateFolderLockRequestBodyLockedOperationsField {
  const move: boolean = val.move;
  const _delete: boolean = val.delete;
  return {
    move: move,
    delete: _delete,
  } satisfies CreateFolderLockRequestBodyLockedOperationsField;
}
export function serializeCreateFolderLockRequestBodyFolderField(
  val: CreateFolderLockRequestBodyFolderField
): SerializedData {
  return { ['type']: val.type, ['id']: val.id };
}
export function deserializeCreateFolderLockRequestBodyFolderField(
  val: any
): CreateFolderLockRequestBodyFolderField {
  const type: string = val.type;
  const id: string = val.id;
  return {
    type: type,
    id: id,
  } satisfies CreateFolderLockRequestBodyFolderField;
}
export function serializeCreateFolderLockRequestBody(
  val: CreateFolderLockRequestBody
): SerializedData {
  return {
    ['locked_operations']:
      val.lockedOperations == void 0
        ? void 0
        : serializeCreateFolderLockRequestBodyLockedOperationsField(
            val.lockedOperations
          ),
    ['folder']: serializeCreateFolderLockRequestBodyFolderField(val.folder),
  };
}
export function deserializeCreateFolderLockRequestBody(
  val: any
): CreateFolderLockRequestBody {
  const lockedOperations:
    | undefined
    | CreateFolderLockRequestBodyLockedOperationsField =
    val.locked_operations == void 0
      ? void 0
      : deserializeCreateFolderLockRequestBodyLockedOperationsField(
          val.locked_operations
        );
  const folder: CreateFolderLockRequestBodyFolderField =
    deserializeCreateFolderLockRequestBodyFolderField(val.folder);
  return {
    lockedOperations: lockedOperations,
    folder: folder,
  } satisfies CreateFolderLockRequestBody;
}

1	import { serializeFolderLocks } from '../schemas.generated.js';
2	import { deserializeFolderLocks } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { serializeFolderLock } from '../schemas.generated.js';
6	import { deserializeFolderLock } from '../schemas.generated.js';	165✔
7	import { FolderLocks } from '../schemas.generated.js';
8	import { ClientError } from '../schemas.generated.js';
9	import { FolderLock } 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 { sdToJson } from '../json.js';
17	import { fetch } from '../fetch.js';	165✔
18	import { FetchOptions } from '../fetch.js';
19	import { FetchResponse } from '../fetch.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';
25	import { sdIsList } from '../json.js';
26	import { sdIsMap } from '../json.js';
27	export interface GetFolderLocksQueryParams {
28	readonly folderId: string;
29	}
30	export class GetFolderLocksHeaders {	165✔
31	readonly extraHeaders?: {	6✔
32	readonly [key: string]: undefined \| string;
33	} = {};
34	constructor(
35	fields:
36	\| Omit<GetFolderLocksHeaders, 'extraHeaders'>
37	\| Partial<Pick<GetFolderLocksHeaders, 'extraHeaders'>>
38	) {
39	Object.assign(this, fields);	6✔
40	}
41	}
42	export interface CreateFolderLockRequestBodyLockedOperationsField {
43	readonly move: boolean;
44	readonly delete: boolean;
45	}
46	export interface CreateFolderLockRequestBodyFolderField {
47	readonly type: string;
48	readonly id: string;
49	}
50	export interface CreateFolderLockRequestBody {
51	readonly lockedOperations?: CreateFolderLockRequestBodyLockedOperationsField;
52	readonly folder: CreateFolderLockRequestBodyFolderField;
53	}
54	export class CreateFolderLockHeaders {	165✔
55	readonly extraHeaders?: {	3✔
56	readonly [key: string]: undefined \| string;
57	} = {};
58	constructor(
59	fields:
60	\| Omit<CreateFolderLockHeaders, 'extraHeaders'>
61	\| Partial<Pick<CreateFolderLockHeaders, 'extraHeaders'>>
62	) {
63	Object.assign(this, fields);	3✔
64	}
65	}
66	export class DeleteFolderLockByIdHeaders {	165✔
67	readonly extraHeaders?: {	6✔
68	readonly [key: string]: undefined \| string;
69	} = {};
70	constructor(
71	fields:
72	\| Omit<DeleteFolderLockByIdHeaders, 'extraHeaders'>
73	\| Partial<Pick<DeleteFolderLockByIdHeaders, 'extraHeaders'>>
74	) {
75	Object.assign(this, fields);	6✔
76	}
77	}
78	export class FolderLocksManager {	165✔
79	readonly auth?: Authentication;
80	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
81	constructor(
82	fields:
83	\| Omit<
84	FolderLocksManager,
85	\| 'networkSession'
86	\| 'getFolderLocks'
87	\| 'createFolderLock'
88	\| 'deleteFolderLockById'
89	>
90	\| Partial<Pick<FolderLocksManager, 'networkSession'>>
91	) {
92	Object.assign(this, fields);	285✔
93	}
94	async getFolderLocks(
95	queryParams: GetFolderLocksQueryParams,
96	headers: GetFolderLocksHeaders = new GetFolderLocksHeaders({}),	6✔
97	cancellationToken?: CancellationToken
98	): Promise<FolderLocks> {
99	const queryParamsMap: {
100	readonly [key: string]: string;
101	} = prepareParams({	6✔
102	['folder_id']: toString(queryParams.folderId) as string,
103	});
104	const headersMap: {
105	readonly [key: string]: string;
106	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
107	const response: FetchResponse = (await fetch(	6✔
108	''.concat(
109	this.networkSession.baseUrls.baseUrl,
110	'/folder_locks'
111	) as string,
112	{
113	method: 'GET',
114	params: queryParamsMap,
115	headers: headersMap,
116	responseFormat: 'json',
117	auth: this.auth,
118	networkSession: this.networkSession,
119	cancellationToken: cancellationToken,
120	} satisfies FetchOptions
121	)) as FetchResponse;
122	return deserializeFolderLocks(response.data);	6✔
123	}
124	async createFolderLock(
125	requestBody: CreateFolderLockRequestBody,
126	headers: CreateFolderLockHeaders = new CreateFolderLockHeaders({}),	3✔
127	cancellationToken?: CancellationToken
128	): Promise<FolderLock> {
129	const headersMap: {
130	readonly [key: string]: string;
131	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
132	const response: FetchResponse = (await fetch(	3✔
133	''.concat(
134	this.networkSession.baseUrls.baseUrl,
135	'/folder_locks'
136	) as string,
137	{
138	method: 'POST',
139	headers: headersMap,
140	data: serializeCreateFolderLockRequestBody(requestBody),
141	contentType: 'application/json',
142	responseFormat: 'json',
143	auth: this.auth,
144	networkSession: this.networkSession,
145	cancellationToken: cancellationToken,
146	} satisfies FetchOptions
147	)) as FetchResponse;
148	return deserializeFolderLock(response.data);	3✔
149	}
150	async deleteFolderLockById(
151	folderLockId: string,
152	headers: DeleteFolderLockByIdHeaders = new DeleteFolderLockByIdHeaders({}),	6✔
153	cancellationToken?: CancellationToken
154	): Promise<undefined> {
155	const headersMap: {
156	readonly [key: string]: string;
157	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
158	const response: FetchResponse = (await fetch(	6✔
159	''.concat(
160	this.networkSession.baseUrls.baseUrl,
161	'/folder_locks/',
162	toString(folderLockId) as string
163	) as string,
164	{
165	method: 'DELETE',
166	headers: headersMap,
167	responseFormat: void 0,
168	auth: this.auth,
169	networkSession: this.networkSession,
170	cancellationToken: cancellationToken,
171	} satisfies FetchOptions
172	)) as FetchResponse;
173	return void 0;	3✔
174	}
175	}
176	export function serializeCreateFolderLockRequestBodyLockedOperationsField(	165✔
177	val: CreateFolderLockRequestBodyLockedOperationsField
178	): SerializedData {
179	return { ['move']: val.move, ['delete']: val.delete };	3✔
180	}
181	export function deserializeCreateFolderLockRequestBodyLockedOperationsField(	165✔
182	val: any
183	): CreateFolderLockRequestBodyLockedOperationsField {
184	const move: boolean = val.move;	×
185	const _delete: boolean = val.delete;	×
186	return {	×
187	move: move,
188	delete: _delete,
189	} satisfies CreateFolderLockRequestBodyLockedOperationsField;
190	}
191	export function serializeCreateFolderLockRequestBodyFolderField(	165✔
192	val: CreateFolderLockRequestBodyFolderField
193	): SerializedData {
194	return { ['type']: val.type, ['id']: val.id };	3✔
195	}
196	export function deserializeCreateFolderLockRequestBodyFolderField(	165✔
197	val: any
198	): CreateFolderLockRequestBodyFolderField {
199	const type: string = val.type;	×
200	const id: string = val.id;	×
201	return {	×
202	type: type,
203	id: id,
204	} satisfies CreateFolderLockRequestBodyFolderField;
205	}
206	export function serializeCreateFolderLockRequestBody(	165✔
207	val: CreateFolderLockRequestBody
208	): SerializedData {
209	return {	3✔
210	['locked_operations']:
211	val.lockedOperations == void 0	3!
212	? void 0
213	: serializeCreateFolderLockRequestBodyLockedOperationsField(
214	val.lockedOperations
215	),
216	['folder']: serializeCreateFolderLockRequestBodyFolderField(val.folder),
217	};
218	}
219	export function deserializeCreateFolderLockRequestBody(	165✔
220	val: any
221	): CreateFolderLockRequestBody {
222	const lockedOperations:
223	\| undefined
224	\| CreateFolderLockRequestBodyLockedOperationsField =
225	val.locked_operations == void 0	×
226	? void 0
227	: deserializeCreateFolderLockRequestBodyLockedOperationsField(
228	val.locked_operations
229	);
230	const folder: CreateFolderLockRequestBodyFolderField =
NEW 231	deserializeCreateFolderLockRequestBodyFolderField(val.folder);	×
UNCOV 232	return {	×
233	lockedOperations: lockedOperations,
234	folder: folder,
235	} satisfies CreateFolderLockRequestBody;
236	}

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