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

78.0

/src/managers/fileWatermarks.generated.ts

import { serializeWatermark } from '../schemas.generated.js';
import { deserializeWatermark } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { Watermark } 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 GetFileWatermarkHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetFileWatermarkHeaders, 'extraHeaders'>
      | Partial<Pick<GetFileWatermarkHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export type UpdateFileWatermarkRequestBodyWatermarkImprintField = 'default';
export interface UpdateFileWatermarkRequestBodyWatermarkField {
  readonly imprint: UpdateFileWatermarkRequestBodyWatermarkImprintField;
}
export interface UpdateFileWatermarkRequestBody {
  readonly watermark: UpdateFileWatermarkRequestBodyWatermarkField;
}
export class UpdateFileWatermarkHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<UpdateFileWatermarkHeaders, 'extraHeaders'>
      | Partial<Pick<UpdateFileWatermarkHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class DeleteFileWatermarkHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<DeleteFileWatermarkHeaders, 'extraHeaders'>
      | Partial<Pick<DeleteFileWatermarkHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class FileWatermarksManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          FileWatermarksManager,
          | 'networkSession'
          | 'getFileWatermark'
          | 'updateFileWatermark'
          | 'deleteFileWatermark'
        >
      | Partial<Pick<FileWatermarksManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getFileWatermark(
    fileId: string,
    headers: GetFileWatermarkHeaders = new GetFileWatermarkHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<Watermark> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/watermark'
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeWatermark(response.data);
  }
  async updateFileWatermark(
    fileId: string,
    requestBody: UpdateFileWatermarkRequestBody,
    headers: UpdateFileWatermarkHeaders = new UpdateFileWatermarkHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<Watermark> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/watermark'
      ) as string,
      {
        method: 'PUT',
        headers: headersMap,
        data: serializeUpdateFileWatermarkRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeWatermark(response.data);
  }
  async deleteFileWatermark(
    fileId: string,
    headers: DeleteFileWatermarkHeaders = new DeleteFileWatermarkHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<undefined> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/files/',
        toString(fileId) as string,
        '/watermark'
      ) 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 serializeUpdateFileWatermarkRequestBodyWatermarkImprintField(
  val: UpdateFileWatermarkRequestBodyWatermarkImprintField
): SerializedData {
  return val;
}
export function deserializeUpdateFileWatermarkRequestBodyWatermarkImprintField(
  val: any
): UpdateFileWatermarkRequestBodyWatermarkImprintField {
  if (!sdIsString(val)) {
    throw 'Expecting a string for "UpdateFileWatermarkRequestBodyWatermarkImprintField"';
  }
  if (val == 'default') {
    return 'default';
  }
  throw ''.concat('Invalid value: ', val) as string;
}
export function serializeUpdateFileWatermarkRequestBodyWatermarkField(
  val: UpdateFileWatermarkRequestBodyWatermarkField
): SerializedData {
  return {
    ['imprint']: serializeUpdateFileWatermarkRequestBodyWatermarkImprintField(
      val.imprint
    ),
  };
}
export function deserializeUpdateFileWatermarkRequestBodyWatermarkField(
  val: any
): UpdateFileWatermarkRequestBodyWatermarkField {
  const imprint: UpdateFileWatermarkRequestBodyWatermarkImprintField =
    deserializeUpdateFileWatermarkRequestBodyWatermarkImprintField(val.imprint);
  return {
    imprint: imprint,
  } satisfies UpdateFileWatermarkRequestBodyWatermarkField;
}
export function serializeUpdateFileWatermarkRequestBody(
  val: UpdateFileWatermarkRequestBody
): SerializedData {
  return {
    ['watermark']: serializeUpdateFileWatermarkRequestBodyWatermarkField(
      val.watermark
    ),
  };
}
export function deserializeUpdateFileWatermarkRequestBody(
  val: any
): UpdateFileWatermarkRequestBody {
  const watermark: UpdateFileWatermarkRequestBodyWatermarkField =
    deserializeUpdateFileWatermarkRequestBodyWatermarkField(val.watermark);
  return { watermark: watermark } satisfies UpdateFileWatermarkRequestBody;
}

1	import { serializeWatermark } from '../schemas.generated.js';
2	import { deserializeWatermark } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { Watermark } 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 GetFileWatermarkHeaders {	165✔
25	readonly extraHeaders?: {	6✔
26	readonly [key: string]: undefined \| string;
27	} = {};
28	constructor(
29	fields:
30	\| Omit<GetFileWatermarkHeaders, 'extraHeaders'>
31	\| Partial<Pick<GetFileWatermarkHeaders, 'extraHeaders'>>
32	) {
33	Object.assign(this, fields);	6✔
34	}
35	}
36	export type UpdateFileWatermarkRequestBodyWatermarkImprintField = 'default';
37	export interface UpdateFileWatermarkRequestBodyWatermarkField {
38	readonly imprint: UpdateFileWatermarkRequestBodyWatermarkImprintField;
39	}
40	export interface UpdateFileWatermarkRequestBody {
41	readonly watermark: UpdateFileWatermarkRequestBodyWatermarkField;
42	}
43	export class UpdateFileWatermarkHeaders {	165✔
44	readonly extraHeaders?: {	3✔
45	readonly [key: string]: undefined \| string;
46	} = {};
47	constructor(
48	fields:
49	\| Omit<UpdateFileWatermarkHeaders, 'extraHeaders'>
50	\| Partial<Pick<UpdateFileWatermarkHeaders, 'extraHeaders'>>
51	) {
52	Object.assign(this, fields);	3✔
53	}
54	}
55	export class DeleteFileWatermarkHeaders {	165✔
56	readonly extraHeaders?: {	3✔
57	readonly [key: string]: undefined \| string;
58	} = {};
59	constructor(
60	fields:
61	\| Omit<DeleteFileWatermarkHeaders, 'extraHeaders'>
62	\| Partial<Pick<DeleteFileWatermarkHeaders, 'extraHeaders'>>
63	) {
64	Object.assign(this, fields);	3✔
65	}
66	}
67	export class FileWatermarksManager {	165✔
68	readonly auth?: Authentication;
69	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
70	constructor(
71	fields:
72	\| Omit<
73	FileWatermarksManager,
74	\| 'networkSession'
75	\| 'getFileWatermark'
76	\| 'updateFileWatermark'
77	\| 'deleteFileWatermark'
78	>
79	\| Partial<Pick<FileWatermarksManager, 'networkSession'>>
80	) {
81	Object.assign(this, fields);	285✔
82	}
83	async getFileWatermark(
84	fileId: string,
85	headers: GetFileWatermarkHeaders = new GetFileWatermarkHeaders({}),	6✔
86	cancellationToken?: CancellationToken
87	): Promise<Watermark> {
88	const headersMap: {
89	readonly [key: string]: string;
90	} = prepareParams({ ...{}, ...headers.extraHeaders });	6✔
91	const response: FetchResponse = (await fetch(	6✔
92	''.concat(
93	this.networkSession.baseUrls.baseUrl,
94	'/files/',
95	toString(fileId) as string,
96	'/watermark'
97	) as string,
98	{
99	method: 'GET',
100	headers: headersMap,
101	responseFormat: 'json',
102	auth: this.auth,
103	networkSession: this.networkSession,
104	cancellationToken: cancellationToken,
105	} satisfies FetchOptions
106	)) as FetchResponse;
107	return deserializeWatermark(response.data);	3✔
108	}
109	async updateFileWatermark(
110	fileId: string,
111	requestBody: UpdateFileWatermarkRequestBody,
112	headers: UpdateFileWatermarkHeaders = new UpdateFileWatermarkHeaders({}),	3✔
113	cancellationToken?: CancellationToken
114	): Promise<Watermark> {
115	const headersMap: {
116	readonly [key: string]: string;
117	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
118	const response: FetchResponse = (await fetch(	3✔
119	''.concat(
120	this.networkSession.baseUrls.baseUrl,
121	'/files/',
122	toString(fileId) as string,
123	'/watermark'
124	) as string,
125	{
126	method: 'PUT',
127	headers: headersMap,
128	data: serializeUpdateFileWatermarkRequestBody(requestBody),
129	contentType: 'application/json',
130	responseFormat: 'json',
131	auth: this.auth,
132	networkSession: this.networkSession,
133	cancellationToken: cancellationToken,
134	} satisfies FetchOptions
135	)) as FetchResponse;
136	return deserializeWatermark(response.data);	3✔
137	}
138	async deleteFileWatermark(
139	fileId: string,
140	headers: DeleteFileWatermarkHeaders = new DeleteFileWatermarkHeaders({}),	3✔
141	cancellationToken?: CancellationToken
142	): Promise<undefined> {
143	const headersMap: {
144	readonly [key: string]: string;
145	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
146	const response: FetchResponse = (await fetch(	3✔
147	''.concat(
148	this.networkSession.baseUrls.baseUrl,
149	'/files/',
150	toString(fileId) as string,
151	'/watermark'
152	) as string,
153	{
154	method: 'DELETE',
155	headers: headersMap,
156	responseFormat: void 0,
157	auth: this.auth,
158	networkSession: this.networkSession,
159	cancellationToken: cancellationToken,
160	} satisfies FetchOptions
161	)) as FetchResponse;
162	return void 0;	3✔
163	}
164	}
165	export function serializeUpdateFileWatermarkRequestBodyWatermarkImprintField(	165✔
166	val: UpdateFileWatermarkRequestBodyWatermarkImprintField
167	): SerializedData {
168	return val;	3✔
169	}
170	export function deserializeUpdateFileWatermarkRequestBodyWatermarkImprintField(	165✔
171	val: any
172	): UpdateFileWatermarkRequestBodyWatermarkImprintField {
173	if (!sdIsString(val)) {	×
NEW 174	throw 'Expecting a string for "UpdateFileWatermarkRequestBodyWatermarkImprintField"';	×
175	}
176	if (val == 'default') {	×
177	return 'default';	×
178	}
179	throw ''.concat('Invalid value: ', val) as string;	×
180	}
181	export function serializeUpdateFileWatermarkRequestBodyWatermarkField(	165✔
182	val: UpdateFileWatermarkRequestBodyWatermarkField
183	): SerializedData {
184	return {	3✔
185	['imprint']: serializeUpdateFileWatermarkRequestBodyWatermarkImprintField(
186	val.imprint
187	),
188	};
189	}
190	export function deserializeUpdateFileWatermarkRequestBodyWatermarkField(	165✔
191	val: any
192	): UpdateFileWatermarkRequestBodyWatermarkField {
193	const imprint: UpdateFileWatermarkRequestBodyWatermarkImprintField =
NEW 194	deserializeUpdateFileWatermarkRequestBodyWatermarkImprintField(val.imprint);	×
UNCOV 195	return {	×
196	imprint: imprint,
197	} satisfies UpdateFileWatermarkRequestBodyWatermarkField;
198	}
199	export function serializeUpdateFileWatermarkRequestBody(	165✔
200	val: UpdateFileWatermarkRequestBody
201	): SerializedData {
202	return {	3✔
203	['watermark']: serializeUpdateFileWatermarkRequestBodyWatermarkField(
204	val.watermark
205	),
206	};
207	}
208	export function deserializeUpdateFileWatermarkRequestBody(	165✔
209	val: any
210	): UpdateFileWatermarkRequestBody {
211	const watermark: UpdateFileWatermarkRequestBodyWatermarkField =
NEW 212	deserializeUpdateFileWatermarkRequestBodyWatermarkField(val.watermark);	×
NEW 213	return { watermark: watermark } satisfies UpdateFileWatermarkRequestBody;	×
214	}

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