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

76.0

/src/managers/invites.generated.ts

import { serializeInvite } from '../schemas.generated.js';
import { deserializeInvite } from '../schemas.generated.js';
import { serializeClientError } from '../schemas.generated.js';
import { deserializeClientError } from '../schemas.generated.js';
import { Invite } 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 { 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 CreateInviteRequestBodyEnterpriseField {
  readonly id: string;
}
export interface CreateInviteRequestBodyActionableByField {
  readonly login?: string;
}
export interface CreateInviteRequestBody {
  readonly enterprise: CreateInviteRequestBodyEnterpriseField;
  readonly actionableBy: CreateInviteRequestBodyActionableByField;
}
export interface CreateInviteQueryParams {
  readonly fields?: readonly string[];
}
export class CreateInviteHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<CreateInviteHeaders, 'extraHeaders'>
      | Partial<Pick<CreateInviteHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export interface GetInviteByIdQueryParams {
  readonly fields?: readonly string[];
}
export class GetInviteByIdHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields:
      | Omit<GetInviteByIdHeaders, 'extraHeaders'>
      | Partial<Pick<GetInviteByIdHeaders, 'extraHeaders'>>
  ) {
    Object.assign(this, fields);
  }
}
export class InvitesManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields:
      | Omit<
          InvitesManager,
          'networkSession' | 'createInvite' | 'getInviteById'
        >
      | Partial<Pick<InvitesManager, 'networkSession'>>
  ) {
    Object.assign(this, fields);
  }
  async createInvite(
    requestBody: CreateInviteRequestBody,
    queryParams: CreateInviteQueryParams = {} satisfies CreateInviteQueryParams,
    headers: CreateInviteHeaders = new CreateInviteHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<Invite> {
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['fields']: queryParams.fields
        ? queryParams.fields.map(toString).join(',')
        : undefined,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(this.networkSession.baseUrls.baseUrl, '/invites') as string,
      {
        method: 'POST',
        params: queryParamsMap,
        headers: headersMap,
        data: serializeCreateInviteRequestBody(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeInvite(response.data);
  }
  async getInviteById(
    inviteId: string,
    queryParams: GetInviteByIdQueryParams = {} satisfies GetInviteByIdQueryParams,
    headers: GetInviteByIdHeaders = new GetInviteByIdHeaders({}),
    cancellationToken?: CancellationToken
  ): Promise<Invite> {
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['fields']: queryParams.fields
        ? queryParams.fields.map(toString).join(',')
        : undefined,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/invites/',
        toString(inviteId) as string
      ) as string,
      {
        method: 'GET',
        params: queryParamsMap,
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeInvite(response.data);
  }
}
export function serializeCreateInviteRequestBodyEnterpriseField(
  val: CreateInviteRequestBodyEnterpriseField
): SerializedData {
  return { ['id']: val.id };
}
export function deserializeCreateInviteRequestBodyEnterpriseField(
  val: any
): CreateInviteRequestBodyEnterpriseField {
  const id: string = val.id;
  return { id: id } satisfies CreateInviteRequestBodyEnterpriseField;
}
export function serializeCreateInviteRequestBodyActionableByField(
  val: CreateInviteRequestBodyActionableByField
): SerializedData {
  return { ['login']: val.login == void 0 ? void 0 : val.login };
}
export function deserializeCreateInviteRequestBodyActionableByField(
  val: any
): CreateInviteRequestBodyActionableByField {
  const login: undefined | string = val.login == void 0 ? void 0 : val.login;
  return { login: login } satisfies CreateInviteRequestBodyActionableByField;
}
export function serializeCreateInviteRequestBody(
  val: CreateInviteRequestBody
): SerializedData {
  return {
    ['enterprise']: serializeCreateInviteRequestBodyEnterpriseField(
      val.enterprise
    ),
    ['actionable_by']: serializeCreateInviteRequestBodyActionableByField(
      val.actionableBy
    ),
  };
}
export function deserializeCreateInviteRequestBody(
  val: any
): CreateInviteRequestBody {
  const enterprise: CreateInviteRequestBodyEnterpriseField =
    deserializeCreateInviteRequestBodyEnterpriseField(val.enterprise);
  const actionableBy: CreateInviteRequestBodyActionableByField =
    deserializeCreateInviteRequestBodyActionableByField(val.actionable_by);
  return {
    enterprise: enterprise,
    actionableBy: actionableBy,
  } satisfies CreateInviteRequestBody;
}

1	import { serializeInvite } from '../schemas.generated.js';
2	import { deserializeInvite } from '../schemas.generated.js';	165✔
3	import { serializeClientError } from '../schemas.generated.js';
4	import { deserializeClientError } from '../schemas.generated.js';
5	import { Invite } 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 { sdToJson } from '../json.js';
14	import { fetch } from '../fetch.js';	165✔
15	import { FetchOptions } from '../fetch.js';
16	import { FetchResponse } from '../fetch.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';
22	import { sdIsList } from '../json.js';
23	import { sdIsMap } from '../json.js';
24	export interface CreateInviteRequestBodyEnterpriseField {
25	readonly id: string;
26	}
27	export interface CreateInviteRequestBodyActionableByField {
28	readonly login?: string;
29	}
30	export interface CreateInviteRequestBody {
31	readonly enterprise: CreateInviteRequestBodyEnterpriseField;
32	readonly actionableBy: CreateInviteRequestBodyActionableByField;
33	}
34	export interface CreateInviteQueryParams {
35	readonly fields?: readonly string[];
36	}
37	export class CreateInviteHeaders {	165✔
38	readonly extraHeaders?: {	3✔
39	readonly [key: string]: undefined \| string;
40	} = {};
41	constructor(
42	fields:
43	\| Omit<CreateInviteHeaders, 'extraHeaders'>
44	\| Partial<Pick<CreateInviteHeaders, 'extraHeaders'>>
45	) {
46	Object.assign(this, fields);	3✔
47	}
48	}
49	export interface GetInviteByIdQueryParams {
50	readonly fields?: readonly string[];
51	}
52	export class GetInviteByIdHeaders {	165✔
53	readonly extraHeaders?: {	3✔
54	readonly [key: string]: undefined \| string;
55	} = {};
56	constructor(
57	fields:
58	\| Omit<GetInviteByIdHeaders, 'extraHeaders'>
59	\| Partial<Pick<GetInviteByIdHeaders, 'extraHeaders'>>
60	) {
61	Object.assign(this, fields);	3✔
62	}
63	}
64	export class InvitesManager {	165✔
65	readonly auth?: Authentication;
66	readonly networkSession: NetworkSession = new NetworkSession({});	285✔
67	constructor(
68	fields:
69	\| Omit<
70	InvitesManager,
71	'networkSession' \| 'createInvite' \| 'getInviteById'
72	>
73	\| Partial<Pick<InvitesManager, 'networkSession'>>
74	) {
75	Object.assign(this, fields);	285✔
76	}
77	async createInvite(
78	requestBody: CreateInviteRequestBody,
79	queryParams: CreateInviteQueryParams = {} satisfies CreateInviteQueryParams,	3✔
80	headers: CreateInviteHeaders = new CreateInviteHeaders({}),	3✔
81	cancellationToken?: CancellationToken
82	): Promise<Invite> {
83	const queryParamsMap: {
84	readonly [key: string]: string;
85	} = prepareParams({	3✔
86	['fields']: queryParams.fields	3!
87	? queryParams.fields.map(toString).join(',')
88	: undefined,
89	});
90	const headersMap: {
91	readonly [key: string]: string;
92	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
93	const response: FetchResponse = (await fetch(	3✔
94	''.concat(this.networkSession.baseUrls.baseUrl, '/invites') as string,
95	{
96	method: 'POST',
97	params: queryParamsMap,
98	headers: headersMap,
99	data: serializeCreateInviteRequestBody(requestBody),
100	contentType: 'application/json',
101	responseFormat: 'json',
102	auth: this.auth,
103	networkSession: this.networkSession,
104	cancellationToken: cancellationToken,
105	} satisfies FetchOptions
106	)) as FetchResponse;
107	return deserializeInvite(response.data);	3✔
108	}
109	async getInviteById(
110	inviteId: string,
111	queryParams: GetInviteByIdQueryParams = {} satisfies GetInviteByIdQueryParams,	3✔
112	headers: GetInviteByIdHeaders = new GetInviteByIdHeaders({}),	3✔
113	cancellationToken?: CancellationToken
114	): Promise<Invite> {
115	const queryParamsMap: {
116	readonly [key: string]: string;
117	} = prepareParams({	3✔
118	['fields']: queryParams.fields	3!
119	? queryParams.fields.map(toString).join(',')
120	: undefined,
121	});
122	const headersMap: {
123	readonly [key: string]: string;
124	} = prepareParams({ ...{}, ...headers.extraHeaders });	3✔
125	const response: FetchResponse = (await fetch(	3✔
126	''.concat(
127	this.networkSession.baseUrls.baseUrl,
128	'/invites/',
129	toString(inviteId) as string
130	) as string,
131	{
132	method: 'GET',
133	params: queryParamsMap,
134	headers: headersMap,
135	responseFormat: 'json',
136	auth: this.auth,
137	networkSession: this.networkSession,
138	cancellationToken: cancellationToken,
139	} satisfies FetchOptions
140	)) as FetchResponse;
141	return deserializeInvite(response.data);	3✔
142	}
143	}
144	export function serializeCreateInviteRequestBodyEnterpriseField(	165✔
145	val: CreateInviteRequestBodyEnterpriseField
146	): SerializedData {
147	return { ['id']: val.id };	3✔
148	}
149	export function deserializeCreateInviteRequestBodyEnterpriseField(	165✔
150	val: any
151	): CreateInviteRequestBodyEnterpriseField {
152	const id: string = val.id;	×
NEW 153	return { id: id } satisfies CreateInviteRequestBodyEnterpriseField;	×
154	}
155	export function serializeCreateInviteRequestBodyActionableByField(	165✔
156	val: CreateInviteRequestBodyActionableByField
157	): SerializedData {
158	return { ['login']: val.login == void 0 ? void 0 : val.login };	3!
159	}
160	export function deserializeCreateInviteRequestBodyActionableByField(	165✔
161	val: any
162	): CreateInviteRequestBodyActionableByField {
163	const login: undefined \| string = val.login == void 0 ? void 0 : val.login;	×
NEW 164	return { login: login } satisfies CreateInviteRequestBodyActionableByField;	×
165	}
166	export function serializeCreateInviteRequestBody(	165✔
167	val: CreateInviteRequestBody
168	): SerializedData {
169	return {	3✔
170	['enterprise']: serializeCreateInviteRequestBodyEnterpriseField(
171	val.enterprise
172	),
173	['actionable_by']: serializeCreateInviteRequestBodyActionableByField(
174	val.actionableBy
175	),
176	};
177	}
178	export function deserializeCreateInviteRequestBody(	165✔
179	val: any
180	): CreateInviteRequestBody {
181	const enterprise: CreateInviteRequestBodyEnterpriseField =
NEW 182	deserializeCreateInviteRequestBodyEnterpriseField(val.enterprise);	×
183	const actionableBy: CreateInviteRequestBodyActionableByField =
NEW 184	deserializeCreateInviteRequestBodyActionableByField(val.actionable_by);	×
UNCOV 185	return {	×
186	enterprise: enterprise,
187	actionableBy: actionableBy,
188	} satisfies CreateInviteRequestBody;
189	}

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