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

91.84

/src/managers/collaborationAllowlistExemptTargets.generated.ts

import { serializeCollaborationAllowlistExemptTargets } from '../schemas.generated.js';
import { deserializeCollaborationAllowlistExemptTargets } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { serializeCollaborationAllowlistExemptTarget } from '../schemas.generated.js';
import { deserializeCollaborationAllowlistExemptTarget } from '../schemas.generated.js';
import { CollaborationAllowlistExemptTargets } from '../schemas.generated.js';
import { ClientError } from '../schemas.generated.js';
import { CollaborationAllowlistExemptTarget } 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 GetCollaborationWhitelistExemptTargetsQueryParams {
  readonly marker?: string;
  readonly limit?: number;
}
export class GetCollaborationWhitelistExemptTargetsHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetCollaborationWhitelistExemptTargetsHeaders, 'extraHeaders'>
      | Partial<
          Pick<GetCollaborationWhitelistExemptTargetsHeaders, 'extraHeaders'>
        >
  ) {
    Object.assign(this, fields);
  }
}
export interface CreateCollaborationWhitelistExemptTargetRequestBodyUserField {
  readonly id: string;
}
export interface CreateCollaborationWhitelistExemptTargetRequestBody {
  readonly user: CreateCollaborationWhitelistExemptTargetRequestBodyUserField;
}
export class CreateCollaborationWhitelistExemptTargetHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<CreateCollaborationWhitelistExemptTargetHeaders, 'extraHeaders'>
      | Partial<
          Pick<CreateCollaborationWhitelistExemptTargetHeaders, 'extraHeaders'>
        >
  ) {
    Object.assign(this, fields);
  }
}
export class GetCollaborationWhitelistExemptTargetByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetCollaborationWhitelistExemptTargetByIdHeaders, 'extraHeaders'>
      | Partial<
          Pick<GetCollaborationWhitelistExemptTargetByIdHeaders, 'extraHeaders'>
        >
  ) {
    Object.assign(this, fields);
  }
}
export class DeleteCollaborationWhitelistExemptTargetByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<
          DeleteCollaborationWhitelistExemptTargetByIdHeaders,
          'extraHeaders'
        >
      | Partial<
          Pick<
            DeleteCollaborationWhitelistExemptTargetByIdHeaders,
            'extraHeaders'
          >
        >
  ) {
    Object.assign(this, fields);
  }
}
export class CollaborationAllowlistExemptTargetsManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          CollaborationAllowlistExemptTargetsManager,
          | 'networkSession'
          | 'getCollaborationWhitelistExemptTargets'
          | 'createCollaborationWhitelistExemptTarget'
          | 'getCollaborationWhitelistExemptTargetById'
          | 'deleteCollaborationWhitelistExemptTargetById'
        >
      | Partial<
          Pick<CollaborationAllowlistExemptTargetsManager, 'networkSession'>
        >
  ) {
    Object.assign(this, fields);
  }
  async getCollaborationWhitelistExemptTargets(
    queryParams: GetCollaborationWhitelistExemptTargetsQueryParams = {} satisfies GetCollaborationWhitelistExemptTargetsQueryParams,
    headers: GetCollaborationWhitelistExemptTargetsHeaders = new GetCollaborationWhitelistExemptTargetsHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<CollaborationAllowlistExemptTargets> {
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['marker']: toString(queryParams.marker) as string,
      ['limit']: toString(queryParams.limit) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/collaboration_whitelist_exempt_targets'
      ) as string,
      {
        method: 'GET',
        params: queryParamsMap,
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeCollaborationAllowlistExemptTargets(response.data);
  }
  async createCollaborationWhitelistExemptTarget(
    requestBody: CreateCollaborationWhitelistExemptTargetRequestBody,
    headers: CreateCollaborationWhitelistExemptTargetHeaders = new CreateCollaborationWhitelistExemptTargetHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<CollaborationAllowlistExemptTarget> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/collaboration_whitelist_exempt_targets'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeCreateCollaborationWhitelistExemptTargetRequestBody(
          requestBody
        ),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeCollaborationAllowlistExemptTarget(response.data);
  }
  async getCollaborationWhitelistExemptTargetById(
    collaborationWhitelistExemptTargetId: string,
    headers: GetCollaborationWhitelistExemptTargetByIdHeaders = new GetCollaborationWhitelistExemptTargetByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<CollaborationAllowlistExemptTarget> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/collaboration_whitelist_exempt_targets/',
        toString(collaborationWhitelistExemptTargetId) as string
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeCollaborationAllowlistExemptTarget(response.data);
  }
  async deleteCollaborationWhitelistExemptTargetById(
    collaborationWhitelistExemptTargetId: string,
    headers: DeleteCollaborationWhitelistExemptTargetByIdHeaders = new DeleteCollaborationWhitelistExemptTargetByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<undefined> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/collaboration_whitelist_exempt_targets/',
        toString(collaborationWhitelistExemptTargetId) 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 serializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(
  val: CreateCollaborationWhitelistExemptTargetRequestBodyUserField
): SerializedData {
  return { ['id']: val.id };
}
export function deserializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(
  val: any
): CreateCollaborationWhitelistExemptTargetRequestBodyUserField {
  const id: string = val.id;
  return {
    id: id,
  } satisfies CreateCollaborationWhitelistExemptTargetRequestBodyUserField;
}
export function serializeCreateCollaborationWhitelistExemptTargetRequestBody(
  val: CreateCollaborationWhitelistExemptTargetRequestBody
): SerializedData {
  return {
    ['user']:
      serializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(
        val.user
      ),
  };
}
export function deserializeCreateCollaborationWhitelistExemptTargetRequestBody(
  val: any
): CreateCollaborationWhitelistExemptTargetRequestBody {
  const user: CreateCollaborationWhitelistExemptTargetRequestBodyUserField =
    deserializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(
      val.user
    );
  return {
    user: user,
  } satisfies CreateCollaborationWhitelistExemptTargetRequestBody;
}

1	import { serializeCollaborationAllowlistExemptTargets } from '../schemas.generated.js';
2	import { deserializeCollaborationAllowlistExemptTargets } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { serializeCollaborationAllowlistExemptTarget } from '../schemas.generated.js';
6	import { deserializeCollaborationAllowlistExemptTarget } from '../schemas.generated.js';	165✔
7	import { CollaborationAllowlistExemptTargets } from '../schemas.generated.js';
8	import { ClientError } from '../schemas.generated.js';
9	import { CollaborationAllowlistExemptTarget } 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 GetCollaborationWhitelistExemptTargetsQueryParams {
28	readonly marker?: string;
29	readonly limit?: number;
30	}
31	export class GetCollaborationWhitelistExemptTargetsHeaders {	165✔
32	readonly extraHeaders?: {	3✔
33	readonly [key: string]: undefined \| string;
34	} = {};
35	constructor(
36	fields:
37	\| Omit<GetCollaborationWhitelistExemptTargetsHeaders, 'extraHeaders'>
38	\| Partial<
39	Pick<GetCollaborationWhitelistExemptTargetsHeaders, 'extraHeaders'>
40	>
41	) {
42	Object.assign(this, fields);	3✔
43	}
44	}
45	export interface CreateCollaborationWhitelistExemptTargetRequestBodyUserField {
46	readonly id: string;
47	}
48	export interface CreateCollaborationWhitelistExemptTargetRequestBody {
49	readonly user: CreateCollaborationWhitelistExemptTargetRequestBodyUserField;
50	}
51	export class CreateCollaborationWhitelistExemptTargetHeaders {	165✔
52	readonly extraHeaders?: {	3✔
53	readonly [key: string]: undefined \| string;
54	} = {};
55	constructor(
56	fields:
57	\| Omit<CreateCollaborationWhitelistExemptTargetHeaders, 'extraHeaders'>
58	\| Partial<
59	Pick<CreateCollaborationWhitelistExemptTargetHeaders, 'extraHeaders'>
60	>
61	) {
62	Object.assign(this, fields);	3✔
63	}
64	}
65	export class GetCollaborationWhitelistExemptTargetByIdHeaders {	165✔
66	readonly extraHeaders?: {	6✔
67	readonly [key: string]: undefined \| string;
68	} = {};
69	constructor(
70	fields:
71	\| Omit<GetCollaborationWhitelistExemptTargetByIdHeaders, 'extraHeaders'>
72	\| Partial<
73	Pick<GetCollaborationWhitelistExemptTargetByIdHeaders, 'extraHeaders'>
74	>
75	) {
76	Object.assign(this, fields);	6✔
77	}
78	}
79	export class DeleteCollaborationWhitelistExemptTargetByIdHeaders {	165✔
80	readonly extraHeaders?: {	3✔
81	readonly [key: string]: undefined \| string;
82	} = {};
83	constructor(
84	fields:
85	\| Omit<
86	DeleteCollaborationWhitelistExemptTargetByIdHeaders,
87	'extraHeaders'
88	>
89	\| Partial<
90	Pick<
91	DeleteCollaborationWhitelistExemptTargetByIdHeaders,
92	'extraHeaders'
93	>
94	>
95	) {
96	Object.assign(this, fields);	3✔
97	}
98	}
99	export class CollaborationAllowlistExemptTargetsManager {	165✔
100	readonly auth?: Authentication;
101	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
102	constructor(
103	fields:
104	\| Omit<
105	CollaborationAllowlistExemptTargetsManager,
106	\| 'networkSession'
107	\| 'getCollaborationWhitelistExemptTargets'
108	\| 'createCollaborationWhitelistExemptTarget'
109	\| 'getCollaborationWhitelistExemptTargetById'
110	\| 'deleteCollaborationWhitelistExemptTargetById'
111	>
112	\| Partial<
113	Pick<CollaborationAllowlistExemptTargetsManager, 'networkSession'>
114	>
115	) {
116	Object.assign(this, fields);	285✔
117	}
118	async getCollaborationWhitelistExemptTargets(
119	queryParams: GetCollaborationWhitelistExemptTargetsQueryParams = {} satisfies GetCollaborationWhitelistExemptTargetsQueryParams,	3✔
120	headers: GetCollaborationWhitelistExemptTargetsHeaders = new GetCollaborationWhitelistExemptTargetsHeaders(	3✔
121	{}
122	),
123	cancellationToken?: CancellationToken
124	): Promise<CollaborationAllowlistExemptTargets> {
125	const queryParamsMap: {
126	readonly [key: string]: string;
127	} = prepareParams({	3✔
128	['marker']: toString(queryParams.marker) as string,
129	['limit']: toString(queryParams.limit) as string,
130	});
131	const headersMap: {
132	readonly [key: string]: string;
133	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
134	const response: FetchResponse = (await fetch(	3✔
135	''.concat(
136	this.networkSession.baseUrls.baseUrl,
137	'/collaboration_whitelist_exempt_targets'
138	) as string,
139	{
140	method: 'GET',
141	params: queryParamsMap,
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 deserializeCollaborationAllowlistExemptTargets(response.data);	3✔
150	}
151	async createCollaborationWhitelistExemptTarget(
152	requestBody: CreateCollaborationWhitelistExemptTargetRequestBody,
153	headers: CreateCollaborationWhitelistExemptTargetHeaders = new CreateCollaborationWhitelistExemptTargetHeaders(	3✔
154	{}
155	),
156	cancellationToken?: CancellationToken
157	): Promise<CollaborationAllowlistExemptTarget> {
158	const headersMap: {
159	readonly [key: string]: string;
160	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
161	const response: FetchResponse = (await fetch(	3✔
162	''.concat(
163	this.networkSession.baseUrls.baseUrl,
164	'/collaboration_whitelist_exempt_targets'
165	) as string,
166	{
167	method: 'POST',
168	headers: headersMap,
169	data: serializeCreateCollaborationWhitelistExemptTargetRequestBody(
170	requestBody
171	),
172	contentType: 'application/json',
173	responseFormat: 'json',
174	auth: this.auth,
175	networkSession: this.networkSession,
176	cancellationToken: cancellationToken,
177	} satisfies FetchOptions
178	)) as FetchResponse;
179	return deserializeCollaborationAllowlistExemptTarget(response.data);	3✔
180	}
181	async getCollaborationWhitelistExemptTargetById(
182	collaborationWhitelistExemptTargetId: string,
183	headers: GetCollaborationWhitelistExemptTargetByIdHeaders = new GetCollaborationWhitelistExemptTargetByIdHeaders(	6✔
184	{}
185	),
186	cancellationToken?: CancellationToken
187	): Promise<CollaborationAllowlistExemptTarget> {
188	const headersMap: {
189	readonly [key: string]: string;
190	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
191	const response: FetchResponse = (await fetch(	6✔
192	''.concat(
193	this.networkSession.baseUrls.baseUrl,
194	'/collaboration_whitelist_exempt_targets/',
195	toString(collaborationWhitelistExemptTargetId) as string
196	) as string,
197	{
198	method: 'GET',
199	headers: headersMap,
200	responseFormat: 'json',
201	auth: this.auth,
202	networkSession: this.networkSession,
203	cancellationToken: cancellationToken,
204	} satisfies FetchOptions
205	)) as FetchResponse;
206	return deserializeCollaborationAllowlistExemptTarget(response.data);	3✔
207	}
208	async deleteCollaborationWhitelistExemptTargetById(
209	collaborationWhitelistExemptTargetId: string,
210	headers: DeleteCollaborationWhitelistExemptTargetByIdHeaders = new DeleteCollaborationWhitelistExemptTargetByIdHeaders(	3✔
211	{}
212	),
213	cancellationToken?: CancellationToken
214	): Promise<undefined> {
215	const headersMap: {
216	readonly [key: string]: string;
217	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
218	const response: FetchResponse = (await fetch(	3✔
219	''.concat(
220	this.networkSession.baseUrls.baseUrl,
221	'/collaboration_whitelist_exempt_targets/',
222	toString(collaborationWhitelistExemptTargetId) as string
223	) as string,
224	{
225	method: 'DELETE',
226	headers: headersMap,
227	responseFormat: void 0,
228	auth: this.auth,
229	networkSession: this.networkSession,
230	cancellationToken: cancellationToken,
231	} satisfies FetchOptions
232	)) as FetchResponse;
233	return void 0;	3✔
234	}
235	}
236	export function serializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(	165✔
237	val: CreateCollaborationWhitelistExemptTargetRequestBodyUserField
238	): SerializedData {
239	return { ['id']: val.id };	3✔
240	}
241	export function deserializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(	165✔
242	val: any
243	): CreateCollaborationWhitelistExemptTargetRequestBodyUserField {
244	const id: string = val.id;	×
245	return {	×
246	id: id,
247	} satisfies CreateCollaborationWhitelistExemptTargetRequestBodyUserField;
248	}
249	export function serializeCreateCollaborationWhitelistExemptTargetRequestBody(	165✔
250	val: CreateCollaborationWhitelistExemptTargetRequestBody
251	): SerializedData {
252	return {	3✔
253	['user']:
254	serializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(
255	val.user
256	),
257	};
258	}
259	export function deserializeCreateCollaborationWhitelistExemptTargetRequestBody(	165✔
260	val: any
261	): CreateCollaborationWhitelistExemptTargetRequestBody {
262	const user: CreateCollaborationWhitelistExemptTargetRequestBodyUserField =
NEW 263	deserializeCreateCollaborationWhitelistExemptTargetRequestBodyUserField(	×
264	val.user
265	);
266	return {	×
267	user: user,
268	} satisfies CreateCollaborationWhitelistExemptTargetRequestBody;
269	}

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