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

94.29

/src/managers/emailAliases.generated.ts

import { serializeEmailAliases } from '../schemas.generated.js';
import { deserializeEmailAliases } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { serializeEmailAlias } from '../schemas.generated.js';
import { deserializeEmailAlias } from '../schemas.generated.js';
import { EmailAliases } from '../schemas.generated.js';
import { ClientError } from '../schemas.generated.js';
import { EmailAlias } 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 GetUserEmailAliasesHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetUserEmailAliasesHeaders, 'extraHeaders'>
      | Partial<Pick<GetUserEmailAliasesHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export interface CreateUserEmailAliasRequestBody {
  readonly email: string;
}
export class CreateUserEmailAliasHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<CreateUserEmailAliasHeaders, 'extraHeaders'>
      | Partial<Pick<CreateUserEmailAliasHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class DeleteUserEmailAliasByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<DeleteUserEmailAliasByIdHeaders, 'extraHeaders'>
      | Partial<Pick<DeleteUserEmailAliasByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class EmailAliasesManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          EmailAliasesManager,
          | 'networkSession'
          | 'getUserEmailAliases'
          | 'createUserEmailAlias'
          | 'deleteUserEmailAliasById'
        >
      | Partial<Pick<EmailAliasesManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async getUserEmailAliases(
    userId: string,
    headers: GetUserEmailAliasesHeaders = new GetUserEmailAliasesHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<EmailAliases> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/users/',
        toString(userId) as string,
        '/email_aliases'
      ) as string,
      {
        method: 'GET',
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeEmailAliases(response.data);
  }
  async createUserEmailAlias(
    userId: string,
    requestBody: CreateUserEmailAliasRequestBody,
    headers: CreateUserEmailAliasHeaders = new CreateUserEmailAliasHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<EmailAlias> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/users/',
        toString(userId) as string,
        '/email_aliases'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeCreateUserEmailAliasRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeEmailAlias(response.data);
  }
  async deleteUserEmailAliasById(
    userId: string,
    emailAliasId: string,
    headers: DeleteUserEmailAliasByIdHeaders = new DeleteUserEmailAliasByIdHeaders(
      {}
    ),
    cancellationToken?: CancellationToken
  ): Promise<undefined> {
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/users/',
        toString(userId) as string,
        '/email_aliases/',
        toString(emailAliasId) 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 serializeCreateUserEmailAliasRequestBody(
  val: CreateUserEmailAliasRequestBody
): SerializedData {
  return { ['email']: val.email };
}
export function deserializeCreateUserEmailAliasRequestBody(
  val: any
): CreateUserEmailAliasRequestBody {
  const email: string = val.email;
  return { email: email } satisfies CreateUserEmailAliasRequestBody;
}

1	import { serializeEmailAliases } from '../schemas.generated.js';
2	import { deserializeEmailAliases } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { serializeEmailAlias } from '../schemas.generated.js';
6	import { deserializeEmailAlias } from '../schemas.generated.js';	165✔
7	import { EmailAliases } from '../schemas.generated.js';
8	import { ClientError } from '../schemas.generated.js';
9	import { EmailAlias } 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 { fetch } from '../fetch.js';	165✔
17	import { FetchOptions } from '../fetch.js';
18	import { FetchResponse } from '../fetch.js';
19	import { sdToJson } from '../json.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 class GetUserEmailAliasesHeaders {	165✔
28	readonly extraHeaders?: {	9✔
29	readonly [key: string]: undefined \| string;
30	} = {};
31	constructor(
32	fields:
33	\| Omit<GetUserEmailAliasesHeaders, 'extraHeaders'>
34	\| Partial<Pick<GetUserEmailAliasesHeaders, 'extraHeaders'>>
35	) {
36	Object.assign(this, fields);	9✔
37	}
38	}
39	export interface CreateUserEmailAliasRequestBody {
40	readonly email: string;
41	}
42	export class CreateUserEmailAliasHeaders {	165✔
43	readonly extraHeaders?: {	3✔
44	readonly [key: string]: undefined \| string;
45	} = {};
46	constructor(
47	fields:
48	\| Omit<CreateUserEmailAliasHeaders, 'extraHeaders'>
49	\| Partial<Pick<CreateUserEmailAliasHeaders, 'extraHeaders'>>
50	) {
51	Object.assign(this, fields);	3✔
52	}
53	}
54	export class DeleteUserEmailAliasByIdHeaders {	165✔
55	readonly extraHeaders?: {	3✔
56	readonly [key: string]: undefined \| string;
57	} = {};
58	constructor(
59	fields:
60	\| Omit<DeleteUserEmailAliasByIdHeaders, 'extraHeaders'>
61	\| Partial<Pick<DeleteUserEmailAliasByIdHeaders, 'extraHeaders'>>
62	) {
63	Object.assign(this, fields);	3✔
64	}
65	}
66	export class EmailAliasesManager {	165✔
67	readonly auth?: Authentication;
68	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
69	constructor(
70	fields:
71	\| Omit<
72	EmailAliasesManager,
73	\| 'networkSession'
74	\| 'getUserEmailAliases'
75	\| 'createUserEmailAlias'
76	\| 'deleteUserEmailAliasById'
77	>
78	\| Partial<Pick<EmailAliasesManager, 'networkSession'>>
79	) {
80	Object.assign(this, fields);	285✔
81	}
82	async getUserEmailAliases(
83	userId: string,
84	headers: GetUserEmailAliasesHeaders = new GetUserEmailAliasesHeaders({}),	9✔
85	cancellationToken?: CancellationToken
86	): Promise<EmailAliases> {
87	const headersMap: {
88	readonly [key: string]: string;
89	} = prepareParams({ ...{}, ...headers.extraHeaders });	9✔
90	const response: FetchResponse = (await fetch(	9✔
91	''.concat(
92	this.networkSession.baseUrls.baseUrl,
93	'/users/',
94	toString(userId) as string,
95	'/email_aliases'
96	) as string,
97	{
98	method: 'GET',
99	headers: headersMap,
100	responseFormat: 'json',
101	auth: this.auth,
102	networkSession: this.networkSession,
103	cancellationToken: cancellationToken,
104	} satisfies FetchOptions
105	)) as FetchResponse;
106	return deserializeEmailAliases(response.data);	9✔
107	}
108	async createUserEmailAlias(
109	userId: string,
110	requestBody: CreateUserEmailAliasRequestBody,
111	headers: CreateUserEmailAliasHeaders = new CreateUserEmailAliasHeaders({}),	3✔
112	cancellationToken?: CancellationToken
113	): Promise<EmailAlias> {
114	const headersMap: {
115	readonly [key: string]: string;
116	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
117	const response: FetchResponse = (await fetch(	3✔
118	''.concat(
119	this.networkSession.baseUrls.baseUrl,
120	'/users/',
121	toString(userId) as string,
122	'/email_aliases'
123	) as string,
124	{
125	method: 'POST',
126	headers: headersMap,
127	data: serializeCreateUserEmailAliasRequestBody(requestBody),
128	contentType: 'application/json',
129	responseFormat: 'json',
130	auth: this.auth,
131	networkSession: this.networkSession,
132	cancellationToken: cancellationToken,
133	} satisfies FetchOptions
134	)) as FetchResponse;
135	return deserializeEmailAlias(response.data);	3✔
136	}
137	async deleteUserEmailAliasById(
138	userId: string,
139	emailAliasId: string,
140	headers: DeleteUserEmailAliasByIdHeaders = new DeleteUserEmailAliasByIdHeaders(	3✔
141	{}
142	),
143	cancellationToken?: CancellationToken
144	): Promise<undefined> {
145	const headersMap: {
146	readonly [key: string]: string;
147	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
148	const response: FetchResponse = (await fetch(	3✔
149	''.concat(
150	this.networkSession.baseUrls.baseUrl,
151	'/users/',
152	toString(userId) as string,
153	'/email_aliases/',
154	toString(emailAliasId) as string
155	) as string,
156	{
157	method: 'DELETE',
158	headers: headersMap,
159	responseFormat: void 0,
160	auth: this.auth,
161	networkSession: this.networkSession,
162	cancellationToken: cancellationToken,
163	} satisfies FetchOptions
164	)) as FetchResponse;
165	return void 0;	3✔
166	}
167	}
168	export function serializeCreateUserEmailAliasRequestBody(	165✔
169	val: CreateUserEmailAliasRequestBody
170	): SerializedData {
171	return { ['email']: val.email };	3✔
172	}
173	export function deserializeCreateUserEmailAliasRequestBody(	165✔
174	val: any
175	): CreateUserEmailAliasRequestBody {
176	const email: string = val.email;	×
NEW 177	return { email: email } satisfies CreateUserEmailAliasRequestBody;	×
178	}

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