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

24.55

/src/managers/termsOfServices.generated.ts

import { serializeTermsOfServices } from '../schemas.generated.js';
import { deserializeTermsOfServices } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { serializeTask } from '../schemas.generated.js';
import { deserializeTask } from '../schemas.generated.js';
import { serializeTermsOfService } from '../schemas.generated.js';
import { deserializeTermsOfService } from '../schemas.generated.js';
import { TermsOfServices } from '../schemas.generated.js';
import { ClientError } from '../schemas.generated.js';
import { Task } from '../schemas.generated.js';
import { TermsOfService } 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 type GetTermsOfServiceQueryParamsTosTypeField = 'external' | 'managed';
export interface GetTermsOfServiceQueryParams {
  readonly tosType?: GetTermsOfServiceQueryParamsTosTypeField;
}
export class GetTermsOfServiceHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetTermsOfServiceHeaders, 'extraHeaders'>
      | Partial<Pick<GetTermsOfServiceHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type CreateTermsOfServiceRequestBodyStatusField = 'enabled' | 'disabled';
export type CreateTermsOfServiceRequestBodyTosTypeField =
  | 'external'
  | 'managed';
export interface CreateTermsOfServiceRequestBody {
  readonly status: CreateTermsOfServiceRequestBodyStatusField;
  readonly tosType?: CreateTermsOfServiceRequestBodyTosTypeField;
  readonly text: string;
}
export class CreateTermsOfServiceHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<CreateTermsOfServiceHeaders, 'extraHeaders'>
      | Partial<Pick<CreateTermsOfServiceHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class GetTermsOfServiceByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetTermsOfServiceByIdHeaders, 'extraHeaders'>
      | Partial<Pick<GetTermsOfServiceByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type UpdateTermsOfServiceByIdRequestBodyStatusField =
  | 'enabled'
  | 'disabled';
export interface UpdateTermsOfServiceByIdRequestBody {
  readonly status: UpdateTermsOfServiceByIdRequestBodyStatusField;
  readonly text: string;
}
export class UpdateTermsOfServiceByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<UpdateTermsOfServiceByIdHeaders, 'extraHeaders'>
      | Partial<Pick<UpdateTermsOfServiceByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class TermsOfServicesManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          TermsOfServicesManager,
          | 'networkSession'
          | 'getTermsOfService'
          | 'createTermsOfService'
          | 'getTermsOfServiceById'
          | 'updateTermsOfServiceById'
        >
      | Partial<Pick<TermsOfServicesManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getTermsOfService(
    queryParams: GetTermsOfServiceQueryParams = {} satisfies GetTermsOfServiceQueryParams,
    headers: GetTermsOfServiceHeaders = new GetTermsOfServiceHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<TermsOfServices> {
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['tos_type']: toString(queryParams.tosType) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/terms_of_services'
      ) as string,
      {
        method: 'GET',
        params: queryParamsMap,
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeTermsOfServices(response.data);
  }
  async createTermsOfService(
    requestBody: CreateTermsOfServiceRequestBody,
    headers: CreateTermsOfServiceHeaders = new CreateTermsOfServiceHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<Task> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/terms_of_services'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeCreateTermsOfServiceRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeTask(response.data);
  }
  async getTermsOfServiceById(
    termsOfServiceId: string,
    headers: GetTermsOfServiceByIdHeaders = new GetTermsOfServiceByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<TermsOfService> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/terms_of_services/',
        toString(termsOfServiceId) as string
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeTermsOfService(response.data);
  }
  async updateTermsOfServiceById(
    termsOfServiceId: string,
    requestBody: UpdateTermsOfServiceByIdRequestBody,
    headers: UpdateTermsOfServiceByIdHeaders = new UpdateTermsOfServiceByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<TermsOfService> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/terms_of_services/',
        toString(termsOfServiceId) as string
      ) as string,
      {
        method: 'PUT',
        headers: headersMap,
        data: serializeUpdateTermsOfServiceByIdRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeTermsOfService(response.data);
  }
}
export function serializeGetTermsOfServiceQueryParamsTosTypeField(
  val: GetTermsOfServiceQueryParamsTosTypeField
): SerializedData {
  return val;
}
export function deserializeGetTermsOfServiceQueryParamsTosTypeField(
  val: any
): GetTermsOfServiceQueryParamsTosTypeField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "GetTermsOfServiceQueryParamsTosTypeField"';
  }
  if (val == 'external') {
    return 'external';
  }
  if (val == 'managed') {
    return 'managed';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeCreateTermsOfServiceRequestBodyStatusField(
  val: CreateTermsOfServiceRequestBodyStatusField
): SerializedData {
  return val;
}
export function deserializeCreateTermsOfServiceRequestBodyStatusField(
  val: any
): CreateTermsOfServiceRequestBodyStatusField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "CreateTermsOfServiceRequestBodyStatusField"';
  }
  if (val == 'enabled') {
    return 'enabled';
  }
  if (val == 'disabled') {
    return 'disabled';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeCreateTermsOfServiceRequestBodyTosTypeField(
  val: CreateTermsOfServiceRequestBodyTosTypeField
): SerializedData {
  return val;
}
export function deserializeCreateTermsOfServiceRequestBodyTosTypeField(
  val: any
): CreateTermsOfServiceRequestBodyTosTypeField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "CreateTermsOfServiceRequestBodyTosTypeField"';
  }
  if (val == 'external') {
    return 'external';
  }
  if (val == 'managed') {
    return 'managed';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeCreateTermsOfServiceRequestBody(
  val: CreateTermsOfServiceRequestBody
): SerializedData {
  return {
    ['status']: serializeCreateTermsOfServiceRequestBodyStatusField(val.status),
    ['tos_type']:
      val.tosType == void 0
        ? void 0
        : serializeCreateTermsOfServiceRequestBodyTosTypeField(val.tosType),
    ['text']: val.text,
  };
}
export function deserializeCreateTermsOfServiceRequestBody(
  val: any
): CreateTermsOfServiceRequestBody {
  const status: CreateTermsOfServiceRequestBodyStatusField =
    deserializeCreateTermsOfServiceRequestBodyStatusField(val.status);
  const tosType: undefined | CreateTermsOfServiceRequestBodyTosTypeField =
    val.tos_type == void 0
      ? void 0
      : deserializeCreateTermsOfServiceRequestBodyTosTypeField(val.tos_type);
  const text: string = val.text;
  return {
    status: status,
    tosType: tosType,
    text: text,
  } satisfies CreateTermsOfServiceRequestBody;
}
export function serializeUpdateTermsOfServiceByIdRequestBodyStatusField(
  val: UpdateTermsOfServiceByIdRequestBodyStatusField
): SerializedData {
  return val;
}
export function deserializeUpdateTermsOfServiceByIdRequestBodyStatusField(
  val: any
): UpdateTermsOfServiceByIdRequestBodyStatusField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateTermsOfServiceByIdRequestBodyStatusField"';
  }
  if (val == 'enabled') {
    return 'enabled';
  }
  if (val == 'disabled') {
    return 'disabled';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateTermsOfServiceByIdRequestBody(
  val: UpdateTermsOfServiceByIdRequestBody
): SerializedData {
  return {
    ['status']: serializeUpdateTermsOfServiceByIdRequestBodyStatusField(
      val.status
    ),
    ['text']: val.text,
  };
}
export function deserializeUpdateTermsOfServiceByIdRequestBody(
  val: any
): UpdateTermsOfServiceByIdRequestBody {
  const status: UpdateTermsOfServiceByIdRequestBodyStatusField =
    deserializeUpdateTermsOfServiceByIdRequestBodyStatusField(val.status);
  const text: string = val.text;
  return {
    status: status,
    text: text,
  } satisfies UpdateTermsOfServiceByIdRequestBody;
}

1	import { serializeTermsOfServices } from '../schemas.generated.js';
2	import { deserializeTermsOfServices } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { serializeTask } from '../schemas.generated.js';
6	import { deserializeTask } from '../schemas.generated.js';	165✔
7	import { serializeTermsOfService } from '../schemas.generated.js';
8	import { deserializeTermsOfService } from '../schemas.generated.js';	165✔
9	import { TermsOfServices } from '../schemas.generated.js';
10	import { ClientError } from '../schemas.generated.js';
11	import { Task } from '../schemas.generated.js';
12	import { TermsOfService } from '../schemas.generated.js';
13	import { Authentication } from '../auth.js';
14	import { NetworkSession } from '../network.js';	165✔
15	import { prepareParams } from '../utils.js';	165✔
16	import { toString } from '../utils.js';	165✔
17	import { ByteStream } from '../utils.js';
18	import { CancellationToken } from '../utils.js';
19	import { sdToJson } from '../json.js';
20	import { fetch } from '../fetch.js';	165✔
21	import { FetchOptions } from '../fetch.js';
22	import { FetchResponse } from '../fetch.js';
23	import { SerializedData } from '../json.js';
24	import { sdIsEmpty } from '../json.js';
25	import { sdIsBoolean } from '../json.js';
26	import { sdIsNumber } from '../json.js';
27	import { sdIsString } from '../json.js';	165✔
28	import { sdIsList } from '../json.js';
29	import { sdIsMap } from '../json.js';
30	export type GetTermsOfServiceQueryParamsTosTypeField = 'external' \| 'managed';
31	export interface GetTermsOfServiceQueryParams {
32	readonly tosType?: GetTermsOfServiceQueryParamsTosTypeField;
33	}
34	export class GetTermsOfServiceHeaders {	165✔
35	readonly extraHeaders?: {	×
36	readonly [key: string]: undefined \| string;
37	} = {};
38	constructor(
39	fields:
40	\| Omit<GetTermsOfServiceHeaders, 'extraHeaders'>
41	\| Partial<Pick<GetTermsOfServiceHeaders, 'extraHeaders'>>
42	) {
43	Object.assign(this, fields);	×
44	}
45	}
46	export type CreateTermsOfServiceRequestBodyStatusField = 'enabled' \| 'disabled';
47	export type CreateTermsOfServiceRequestBodyTosTypeField =
48	\| 'external'
49	\| 'managed';
50	export interface CreateTermsOfServiceRequestBody {
51	readonly status: CreateTermsOfServiceRequestBodyStatusField;
52	readonly tosType?: CreateTermsOfServiceRequestBodyTosTypeField;
53	readonly text: string;
54	}
55	export class CreateTermsOfServiceHeaders {	165✔
56	readonly extraHeaders?: {	×
57	readonly [key: string]: undefined \| string;
58	} = {};
59	constructor(
60	fields:
61	\| Omit<CreateTermsOfServiceHeaders, 'extraHeaders'>
62	\| Partial<Pick<CreateTermsOfServiceHeaders, 'extraHeaders'>>
63	) {
64	Object.assign(this, fields);	×
65	}
66	}
67	export class GetTermsOfServiceByIdHeaders {	165✔
68	readonly extraHeaders?: {	×
69	readonly [key: string]: undefined \| string;
70	} = {};
71	constructor(
72	fields:
73	\| Omit<GetTermsOfServiceByIdHeaders, 'extraHeaders'>
74	\| Partial<Pick<GetTermsOfServiceByIdHeaders, 'extraHeaders'>>
75	) {
76	Object.assign(this, fields);	×
77	}
78	}
79	export type UpdateTermsOfServiceByIdRequestBodyStatusField =
80	\| 'enabled'
81	\| 'disabled';
82	export interface UpdateTermsOfServiceByIdRequestBody {
83	readonly status: UpdateTermsOfServiceByIdRequestBodyStatusField;
84	readonly text: string;
85	}
86	export class UpdateTermsOfServiceByIdHeaders {	165✔
87	readonly extraHeaders?: {	×
88	readonly [key: string]: undefined \| string;
89	} = {};
90	constructor(
91	fields:
92	\| Omit<UpdateTermsOfServiceByIdHeaders, 'extraHeaders'>
93	\| Partial<Pick<UpdateTermsOfServiceByIdHeaders, 'extraHeaders'>>
94	) {
95	Object.assign(this, fields);	×
96	}
97	}
98	export class TermsOfServicesManager {	165✔
99	readonly auth?: Authentication;
100	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
101	constructor(
102	fields:
103	\| Omit<
104	TermsOfServicesManager,
105	\| 'networkSession'
106	\| 'getTermsOfService'
107	\| 'createTermsOfService'
108	\| 'getTermsOfServiceById'
109	\| 'updateTermsOfServiceById'
110	>
111	\| Partial<Pick<TermsOfServicesManager, 'networkSession'>>
112	) {
113	Object.assign(this, fields);	285✔
114	}
115	async getTermsOfService(
116	queryParams: GetTermsOfServiceQueryParams = {} satisfies GetTermsOfServiceQueryParams,	×
117	headers: GetTermsOfServiceHeaders = new GetTermsOfServiceHeaders({}),	×
118	cancellationToken?: CancellationToken
119	): Promise<TermsOfServices> {
120	const queryParamsMap: {
121	readonly [key: string]: string;
122	} = prepareParams({	×
123	['tos_type']: toString(queryParams.tosType) as string,
124	});
125	const headersMap: {
126	readonly [key: string]: string;
127	} = prepareParams({ ...{}, ...headers.extraHeaders });	×
128	const response: FetchResponse = (await fetch(	×
129	''.concat(
130	this.networkSession.baseUrls.baseUrl,
131	'/terms_of_services'
132	) as string,
133	{
134	method: 'GET',
135	params: queryParamsMap,
136	headers: headersMap,
137	responseFormat: 'json',
138	auth: this.auth,
139	networkSession: this.networkSession,
140	cancellationToken: cancellationToken,
141	} satisfies FetchOptions
142	)) as FetchResponse;
143	return deserializeTermsOfServices(response.data);	×
144	}
145	async createTermsOfService(
146	requestBody: CreateTermsOfServiceRequestBody,
147	headers: CreateTermsOfServiceHeaders = new CreateTermsOfServiceHeaders({}),	×
148	cancellationToken?: CancellationToken
149	): Promise<Task> {
150	const headersMap: {
151	readonly [key: string]: string;
152	} = prepareParams({ ...{}, ...headers.extraHeaders });	×
153	const response: FetchResponse = (await fetch(	×
154	''.concat(
155	this.networkSession.baseUrls.baseUrl,
156	'/terms_of_services'
157	) as string,
158	{
159	method: 'POST',
160	headers: headersMap,
161	data: serializeCreateTermsOfServiceRequestBody(requestBody),
162	contentType: 'application/json',
163	responseFormat: 'json',
164	auth: this.auth,
165	networkSession: this.networkSession,
166	cancellationToken: cancellationToken,
167	} satisfies FetchOptions
168	)) as FetchResponse;
169	return deserializeTask(response.data);	×
170	}
171	async getTermsOfServiceById(
172	termsOfServiceId: string,
173	headers: GetTermsOfServiceByIdHeaders = new GetTermsOfServiceByIdHeaders(	×
174	{}
175	),
176	cancellationToken?: CancellationToken
177	): Promise<TermsOfService> {
178	const headersMap: {
179	readonly [key: string]: string;
180	} = prepareParams({ ...{}, ...headers.extraHeaders });	×
181	const response: FetchResponse = (await fetch(	×
182	''.concat(
183	this.networkSession.baseUrls.baseUrl,
184	'/terms_of_services/',
185	toString(termsOfServiceId) as string
186	) as string,
187	{
188	method: 'GET',
189	headers: headersMap,
190	responseFormat: 'json',
191	auth: this.auth,
192	networkSession: this.networkSession,
193	cancellationToken: cancellationToken,
194	} satisfies FetchOptions
195	)) as FetchResponse;
196	return deserializeTermsOfService(response.data);	×
197	}
198	async updateTermsOfServiceById(
199	termsOfServiceId: string,
200	requestBody: UpdateTermsOfServiceByIdRequestBody,
201	headers: UpdateTermsOfServiceByIdHeaders = new UpdateTermsOfServiceByIdHeaders(	×
202	{}
203	),
204	cancellationToken?: CancellationToken
205	): Promise<TermsOfService> {
206	const headersMap: {
207	readonly [key: string]: string;
208	} = prepareParams({ ...{}, ...headers.extraHeaders });	×
209	const response: FetchResponse = (await fetch(	×
210	''.concat(
211	this.networkSession.baseUrls.baseUrl,
212	'/terms_of_services/',
213	toString(termsOfServiceId) as string
214	) as string,
215	{
216	method: 'PUT',
217	headers: headersMap,
218	data: serializeUpdateTermsOfServiceByIdRequestBody(requestBody),
219	contentType: 'application/json',
220	responseFormat: 'json',
221	auth: this.auth,
222	networkSession: this.networkSession,
223	cancellationToken: cancellationToken,
224	} satisfies FetchOptions
225	)) as FetchResponse;
226	return deserializeTermsOfService(response.data);	×
227	}
228	}
229	export function serializeGetTermsOfServiceQueryParamsTosTypeField(	165✔
230	val: GetTermsOfServiceQueryParamsTosTypeField
231	): SerializedData {
232	return val;	×
233	}
234	export function deserializeGetTermsOfServiceQueryParamsTosTypeField(	165✔
235	val: any
236	): GetTermsOfServiceQueryParamsTosTypeField {
237	if (!sdIsString(val)) {	×
NEW 238	throw 'Expecting a string for "GetTermsOfServiceQueryParamsTosTypeField"';	×
239	}
240	if (val == 'external') {	×
241	return 'external';	×
242	}
243	if (val == 'managed') {	×
244	return 'managed';	×
245	}
246	throw ''.concat('Invalid value: ', val) as string;	×
247	}
248	export function serializeCreateTermsOfServiceRequestBodyStatusField(	165✔
249	val: CreateTermsOfServiceRequestBodyStatusField
250	): SerializedData {
251	return val;	×
252	}
253	export function deserializeCreateTermsOfServiceRequestBodyStatusField(	165✔
254	val: any
255	): CreateTermsOfServiceRequestBodyStatusField {
256	if (!sdIsString(val)) {	×
NEW 257	throw 'Expecting a string for "CreateTermsOfServiceRequestBodyStatusField"';	×
258	}
259	if (val == 'enabled') {	×
260	return 'enabled';	×
261	}
262	if (val == 'disabled') {	×
263	return 'disabled';	×
264	}
265	throw ''.concat('Invalid value: ', val) as string;	×
266	}
267	export function serializeCreateTermsOfServiceRequestBodyTosTypeField(	165✔
268	val: CreateTermsOfServiceRequestBodyTosTypeField
269	): SerializedData {
270	return val;	×
271	}
272	export function deserializeCreateTermsOfServiceRequestBodyTosTypeField(	165✔
273	val: any
274	): CreateTermsOfServiceRequestBodyTosTypeField {
275	if (!sdIsString(val)) {	×
NEW 276	throw 'Expecting a string for "CreateTermsOfServiceRequestBodyTosTypeField"';	×
277	}
278	if (val == 'external') {	×
279	return 'external';	×
280	}
281	if (val == 'managed') {	×
282	return 'managed';	×
283	}
284	throw ''.concat('Invalid value: ', val) as string;	×
285	}
286	export function serializeCreateTermsOfServiceRequestBody(	165✔
287	val: CreateTermsOfServiceRequestBody
288	): SerializedData {
289	return {	×
290	['status']: serializeCreateTermsOfServiceRequestBodyStatusField(val.status),
291	['tos_type']:
292	val.tosType == void 0	×
293	? void 0
294	: serializeCreateTermsOfServiceRequestBodyTosTypeField(val.tosType),
295	['text']: val.text,
296	};
297	}
298	export function deserializeCreateTermsOfServiceRequestBody(	165✔
299	val: any
300	): CreateTermsOfServiceRequestBody {
301	const status: CreateTermsOfServiceRequestBodyStatusField =
NEW 302	deserializeCreateTermsOfServiceRequestBodyStatusField(val.status);	×
303	const tosType: undefined \| CreateTermsOfServiceRequestBodyTosTypeField =
UNCOV 304	val.tos_type == void 0	×
305	? void 0
306	: deserializeCreateTermsOfServiceRequestBodyTosTypeField(val.tos_type);
307	const text: string = val.text;	×
308	return {	×
309	status: status,
310	tosType: tosType,
311	text: text,
312	} satisfies CreateTermsOfServiceRequestBody;
313	}
314	export function serializeUpdateTermsOfServiceByIdRequestBodyStatusField(	165✔
315	val: UpdateTermsOfServiceByIdRequestBodyStatusField
316	): SerializedData {
317	return val;	×
318	}
319	export function deserializeUpdateTermsOfServiceByIdRequestBodyStatusField(	165✔
320	val: any
321	): UpdateTermsOfServiceByIdRequestBodyStatusField {
322	if (!sdIsString(val)) {	×
NEW 323	throw 'Expecting a string for "UpdateTermsOfServiceByIdRequestBodyStatusField"';	×
324	}
325	if (val == 'enabled') {	×
326	return 'enabled';	×
327	}
328	if (val == 'disabled') {	×
329	return 'disabled';	×
330	}
331	throw ''.concat('Invalid value: ', val) as string;	×
332	}
333	export function serializeUpdateTermsOfServiceByIdRequestBody(	165✔
334	val: UpdateTermsOfServiceByIdRequestBody
335	): SerializedData {
336	return {	×
337	['status']: serializeUpdateTermsOfServiceByIdRequestBodyStatusField(
338	val.status
339	),
340	['text']: val.text,
341	};
342	}
343	export function deserializeUpdateTermsOfServiceByIdRequestBody(	165✔
344	val: any
345	): UpdateTermsOfServiceByIdRequestBody {
346	const status: UpdateTermsOfServiceByIdRequestBodyStatusField =
NEW 347	deserializeUpdateTermsOfServiceByIdRequestBodyStatusField(val.status);	×
348	const text: string = val.text;	×
349	return {	×
350	status: status,
351	text: text,
352	} satisfies UpdateTermsOfServiceByIdRequestBody;
353	}

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