10523193890

Committed 23 Aug 2024 09:16AM UTC coverage: 41.971% (+0.02%) from 41.947%

Build # 10523193890

Build Type

Pull #319

github

Committed by

web-flow

Commit Message

Merge 31709e0df into 340fbd84f

Pull Request Pull Request #319: feat: Include URL into FetchOptions (box/box-codegen#549)

Run Details

4005 of 16427 branches covered (24.38%)

Branch coverage included in aggregate %.

248 of 273 new or added lines in 71 files covered. (90.84%)

27 existing lines in 18 files now uncovered.

13050 of 24208 relevant lines covered (53.91%)

74.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

43.9

/src/managers/shieldInformationBarrierReports.generated.ts

import { serializeShieldInformationBarrierReports } from '../schemas/shieldInformationBarrierReports.generated.js';
import { deserializeShieldInformationBarrierReports } from '../schemas/shieldInformationBarrierReports.generated.js';
import { serializeClientError } from '../schemas/clientError.generated.js';
import { deserializeClientError } from '../schemas/clientError.generated.js';
import { serializeShieldInformationBarrierReport } from '../schemas/shieldInformationBarrierReport.generated.js';
import { deserializeShieldInformationBarrierReport } from '../schemas/shieldInformationBarrierReport.generated.js';
import { serializeShieldInformationBarrierReference } from '../schemas/shieldInformationBarrierReference.generated.js';
import { deserializeShieldInformationBarrierReference } from '../schemas/shieldInformationBarrierReference.generated.js';
import { ShieldInformationBarrierReports } from '../schemas/shieldInformationBarrierReports.generated.js';
import { ClientError } from '../schemas/clientError.generated.js';
import { ShieldInformationBarrierReport } from '../schemas/shieldInformationBarrierReport.generated.js';
import { ShieldInformationBarrierReference } from '../schemas/shieldInformationBarrierReference.generated.js';
import { Authentication } from '../networking/auth.generated.js';
import { NetworkSession } from '../networking/network.generated.js';
import { prepareParams } from '../internal/utils.js';
import { toString } from '../internal/utils.js';
import { ByteStream } from '../internal/utils.js';
import { CancellationToken } from '../internal/utils.js';
import { sdToJson } from '../serialization/json.js';
import { FetchOptions } from '../networking/fetch.js';
import { FetchResponse } from '../networking/fetch.js';
import { fetch } from '../networking/fetch.js';
import { SerializedData } from '../serialization/json.js';
import { sdIsEmpty } from '../serialization/json.js';
import { sdIsBoolean } from '../serialization/json.js';
import { sdIsNumber } from '../serialization/json.js';
import { sdIsString } from '../serialization/json.js';
import { sdIsList } from '../serialization/json.js';
import { sdIsMap } from '../serialization/json.js';
export class GetShieldInformationBarrierReportsOptionals {
  readonly headers: GetShieldInformationBarrierReportsHeaders =
    new GetShieldInformationBarrierReportsHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      GetShieldInformationBarrierReportsOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<
          GetShieldInformationBarrierReportsOptionals,
          'headers' | 'cancellationToken'
        >
      >
  ) {
    if (fields.headers) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface GetShieldInformationBarrierReportsOptionalsInput {
  readonly headers?: GetShieldInformationBarrierReportsHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class CreateShieldInformationBarrierReportOptionals {
  readonly headers: CreateShieldInformationBarrierReportHeaders =
    new CreateShieldInformationBarrierReportHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      CreateShieldInformationBarrierReportOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<
          CreateShieldInformationBarrierReportOptionals,
          'headers' | 'cancellationToken'
        >
      >
  ) {
    if (fields.headers) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface CreateShieldInformationBarrierReportOptionalsInput {
  readonly headers?: CreateShieldInformationBarrierReportHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class GetShieldInformationBarrierReportByIdOptionals {
  readonly headers: GetShieldInformationBarrierReportByIdHeaders =
    new GetShieldInformationBarrierReportByIdHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      GetShieldInformationBarrierReportByIdOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<
          GetShieldInformationBarrierReportByIdOptionals,
          'headers' | 'cancellationToken'
        >
      >
  ) {
    if (fields.headers) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface GetShieldInformationBarrierReportByIdOptionalsInput {
  readonly headers?: GetShieldInformationBarrierReportByIdHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export interface GetShieldInformationBarrierReportsQueryParams {
  /**
   * The ID of the shield information barrier. */
  readonly shieldInformationBarrierId: string;
  /**
   * Defines the position marker at which to begin returning results. This is
   * used when paginating using marker-based pagination.
   *
   * This requires `usemarker` to be set to `true`. */
  readonly marker?: string;
  /**
   * The maximum number of items to return per page. */
  readonly limit?: number;
}
export class GetShieldInformationBarrierReportsHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetShieldInformationBarrierReportsHeaders, 'extraHeaders'> &
      Partial<Pick<GetShieldInformationBarrierReportsHeaders, 'extraHeaders'>>
  ) {
    if (fields.extraHeaders) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetShieldInformationBarrierReportsHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class CreateShieldInformationBarrierReportHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<CreateShieldInformationBarrierReportHeaders, 'extraHeaders'> &
      Partial<Pick<CreateShieldInformationBarrierReportHeaders, 'extraHeaders'>>
  ) {
    if (fields.extraHeaders) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface CreateShieldInformationBarrierReportHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class GetShieldInformationBarrierReportByIdHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetShieldInformationBarrierReportByIdHeaders, 'extraHeaders'> &
      Partial<
        Pick<GetShieldInformationBarrierReportByIdHeaders, 'extraHeaders'>
      >
  ) {
    if (fields.extraHeaders) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetShieldInformationBarrierReportByIdHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class ShieldInformationBarrierReportsManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields: Omit<
      ShieldInformationBarrierReportsManager,
      | 'networkSession'
      | 'getShieldInformationBarrierReports'
      | 'createShieldInformationBarrierReport'
      | 'getShieldInformationBarrierReportById'
    > &
      Partial<Pick<ShieldInformationBarrierReportsManager, 'networkSession'>>
  ) {
    if (fields.auth) {
      this.auth = fields.auth;
    }
    if (fields.networkSession) {
      this.networkSession = fields.networkSession;
    }
  }
  /**
   * Lists shield information barrier reports.
   * @param {GetShieldInformationBarrierReportsQueryParams} queryParams Query parameters of getShieldInformationBarrierReports method
   * @param {GetShieldInformationBarrierReportsOptionalsInput} optionalsInput
   * @returns {Promise<ShieldInformationBarrierReports>}
   */
  async getShieldInformationBarrierReports(
    queryParams: GetShieldInformationBarrierReportsQueryParams,
    optionalsInput: GetShieldInformationBarrierReportsOptionalsInput = {}
  ): Promise<ShieldInformationBarrierReports> {
    const optionals: GetShieldInformationBarrierReportsOptionals =
      new GetShieldInformationBarrierReportsOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['shield_information_barrier_id']: toString(
        queryParams.shieldInformationBarrierId
      ) as string,
      ['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({
      url: ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/2.0/shield_information_barrier_reports'
      ) as string,
      method: 'GET',
      params: queryParamsMap,
      headers: headersMap,
      responseFormat: 'json',
      auth: this.auth,
      networkSession: this.networkSession,
      cancellationToken: cancellationToken,
    } satisfies FetchOptions)) as FetchResponse;
    return deserializeShieldInformationBarrierReports(response.data);
  }
  /**
   * Creates a shield information barrier report for a given barrier.
   * @param {ShieldInformationBarrierReference} requestBody Request body of createShieldInformationBarrierReport method
   * @param {CreateShieldInformationBarrierReportOptionalsInput} optionalsInput
   * @returns {Promise<ShieldInformationBarrierReport>}
   */
  async createShieldInformationBarrierReport(
    requestBody: ShieldInformationBarrierReference,
    optionalsInput: CreateShieldInformationBarrierReportOptionalsInput = {}
  ): Promise<ShieldInformationBarrierReport> {
    const optionals: CreateShieldInformationBarrierReportOptionals =
      new CreateShieldInformationBarrierReportOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch({
      url: ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/2.0/shield_information_barrier_reports'
      ) as string,
      method: 'POST',
      headers: headersMap,
      data: serializeShieldInformationBarrierReference(requestBody),
      contentType: 'application/json',
      responseFormat: 'json',
      auth: this.auth,
      networkSession: this.networkSession,
      cancellationToken: cancellationToken,
    } satisfies FetchOptions)) as FetchResponse;
    return deserializeShieldInformationBarrierReport(response.data);
  }
  /**
     * Retrieves a shield information barrier report by its ID.
     * @param {string} shieldInformationBarrierReportId The ID of the shield information barrier Report.
    Example: "3423"
     * @param {GetShieldInformationBarrierReportByIdOptionalsInput} optionalsInput
     * @returns {Promise<ShieldInformationBarrierReport>}
     */
  async getShieldInformationBarrierReportById(
    shieldInformationBarrierReportId: string,
    optionalsInput: GetShieldInformationBarrierReportByIdOptionalsInput = {}
  ): Promise<ShieldInformationBarrierReport> {
    const optionals: GetShieldInformationBarrierReportByIdOptionals =
      new GetShieldInformationBarrierReportByIdOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch({
      url: ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/2.0/shield_information_barrier_reports/',
        toString(shieldInformationBarrierReportId) as string
      ) as string,
      method: 'GET',
      headers: headersMap,
      responseFormat: 'json',
      auth: this.auth,
      networkSession: this.networkSession,
      cancellationToken: cancellationToken,
    } satisfies FetchOptions)) as FetchResponse;
    return deserializeShieldInformationBarrierReport(response.data);
  }
}
export interface ShieldInformationBarrierReportsManagerInput {
  readonly auth?: Authentication;
  readonly networkSession?: NetworkSession;
}

1	import { serializeShieldInformationBarrierReports } from '../schemas/shieldInformationBarrierReports.generated.js';
2	import { deserializeShieldInformationBarrierReports } from '../schemas/shieldInformationBarrierReports.generated.js';	138✔
3	import { serializeClientError } from '../schemas/clientError.generated.js';
4	import { deserializeClientError } from '../schemas/clientError.generated.js';
5	import { serializeShieldInformationBarrierReport } from '../schemas/shieldInformationBarrierReport.generated.js';
6	import { deserializeShieldInformationBarrierReport } from '../schemas/shieldInformationBarrierReport.generated.js';	138✔
7	import { serializeShieldInformationBarrierReference } from '../schemas/shieldInformationBarrierReference.generated.js';	138✔
8	import { deserializeShieldInformationBarrierReference } from '../schemas/shieldInformationBarrierReference.generated.js';
9	import { ShieldInformationBarrierReports } from '../schemas/shieldInformationBarrierReports.generated.js';
10	import { ClientError } from '../schemas/clientError.generated.js';
11	import { ShieldInformationBarrierReport } from '../schemas/shieldInformationBarrierReport.generated.js';
12	import { ShieldInformationBarrierReference } from '../schemas/shieldInformationBarrierReference.generated.js';
13	import { Authentication } from '../networking/auth.generated.js';
14	import { NetworkSession } from '../networking/network.generated.js';	138✔
15	import { prepareParams } from '../internal/utils.js';	138✔
16	import { toString } from '../internal/utils.js';	138✔
17	import { ByteStream } from '../internal/utils.js';
18	import { CancellationToken } from '../internal/utils.js';
19	import { sdToJson } from '../serialization/json.js';
20	import { FetchOptions } from '../networking/fetch.js';
21	import { FetchResponse } from '../networking/fetch.js';
22	import { fetch } from '../networking/fetch.js';	138✔
23	import { SerializedData } from '../serialization/json.js';
24	import { sdIsEmpty } from '../serialization/json.js';
25	import { sdIsBoolean } from '../serialization/json.js';
26	import { sdIsNumber } from '../serialization/json.js';
27	import { sdIsString } from '../serialization/json.js';
28	import { sdIsList } from '../serialization/json.js';
29	import { sdIsMap } from '../serialization/json.js';
30	export class GetShieldInformationBarrierReportsOptionals {	138✔
31	readonly headers: GetShieldInformationBarrierReportsHeaders =	2✔
32	new GetShieldInformationBarrierReportsHeaders({});
33	readonly cancellationToken?: CancellationToken = void 0;	2✔
34	constructor(
35	fields: Omit<
36	GetShieldInformationBarrierReportsOptionals,
37	'headers' \| 'cancellationToken'
38	> &
39	Partial<
40	Pick<
41	GetShieldInformationBarrierReportsOptionals,
42	'headers' \| 'cancellationToken'
43	>
44	>
45	) {
46	if (fields.headers) {	2!
47	this.headers = fields.headers;	×
48	}
49	if (fields.cancellationToken) {	2!
50	this.cancellationToken = fields.cancellationToken;	×
51	}
52	}
53	}
54	export interface GetShieldInformationBarrierReportsOptionalsInput {
55	readonly headers?: GetShieldInformationBarrierReportsHeaders;
56	readonly cancellationToken?: undefined \| CancellationToken;
57	}
58	export class CreateShieldInformationBarrierReportOptionals {	138✔
59	readonly headers: CreateShieldInformationBarrierReportHeaders =	×
60	new CreateShieldInformationBarrierReportHeaders({});
61	readonly cancellationToken?: CancellationToken = void 0;	×
62	constructor(
63	fields: Omit<
64	CreateShieldInformationBarrierReportOptionals,
65	'headers' \| 'cancellationToken'
66	> &
67	Partial<
68	Pick<
69	CreateShieldInformationBarrierReportOptionals,
70	'headers' \| 'cancellationToken'
71	>
72	>
73	) {
74	if (fields.headers) {	×
75	this.headers = fields.headers;	×
76	}
77	if (fields.cancellationToken) {	×
78	this.cancellationToken = fields.cancellationToken;	×
79	}
80	}
81	}
82	export interface CreateShieldInformationBarrierReportOptionalsInput {
83	readonly headers?: CreateShieldInformationBarrierReportHeaders;
84	readonly cancellationToken?: undefined \| CancellationToken;
85	}
86	export class GetShieldInformationBarrierReportByIdOptionals {	138✔
87	readonly headers: GetShieldInformationBarrierReportByIdHeaders =	×
88	new GetShieldInformationBarrierReportByIdHeaders({});
89	readonly cancellationToken?: CancellationToken = void 0;	×
90	constructor(
91	fields: Omit<
92	GetShieldInformationBarrierReportByIdOptionals,
93	'headers' \| 'cancellationToken'
94	> &
95	Partial<
96	Pick<
97	GetShieldInformationBarrierReportByIdOptionals,
98	'headers' \| 'cancellationToken'
99	>
100	>
101	) {
102	if (fields.headers) {	×
103	this.headers = fields.headers;	×
104	}
105	if (fields.cancellationToken) {	×
106	this.cancellationToken = fields.cancellationToken;	×
107	}
108	}
109	}
110	export interface GetShieldInformationBarrierReportByIdOptionalsInput {
111	readonly headers?: GetShieldInformationBarrierReportByIdHeaders;
112	readonly cancellationToken?: undefined \| CancellationToken;
113	}
114	export interface GetShieldInformationBarrierReportsQueryParams {
115	/**
116	* The ID of the shield information barrier. */
117	readonly shieldInformationBarrierId: string;
118	/**
119	* Defines the position marker at which to begin returning results. This is
120	* used when paginating using marker-based pagination.
121	*
122	* This requires `usemarker` to be set to `true`. */
123	readonly marker?: string;
124	/**
125	* The maximum number of items to return per page. */
126	readonly limit?: number;
127	}
128	export class GetShieldInformationBarrierReportsHeaders {	138✔
129	/**
130	* Extra headers that will be included in the HTTP request. */
131	readonly extraHeaders?: {	2✔
132	readonly [key: string]: undefined \| string;
133	} = {};
134	constructor(
135	fields: Omit<GetShieldInformationBarrierReportsHeaders, 'extraHeaders'> &
136	Partial<Pick<GetShieldInformationBarrierReportsHeaders, 'extraHeaders'>>
137	) {
138	if (fields.extraHeaders) {	2!
139	this.extraHeaders = fields.extraHeaders;	×
140	}
141	}
142	}
143	export interface GetShieldInformationBarrierReportsHeadersInput {
144	/**
145	* Extra headers that will be included in the HTTP request. */
146	readonly extraHeaders?:
147	\| undefined
148	\| {
149	readonly [key: string]: undefined \| string;
150	};
151	}
152	export class CreateShieldInformationBarrierReportHeaders {	138✔
153	/**
154	* Extra headers that will be included in the HTTP request. */
155	readonly extraHeaders?: {	×
156	readonly [key: string]: undefined \| string;
157	} = {};
158	constructor(
159	fields: Omit<CreateShieldInformationBarrierReportHeaders, 'extraHeaders'> &
160	Partial<Pick<CreateShieldInformationBarrierReportHeaders, 'extraHeaders'>>
161	) {
162	if (fields.extraHeaders) {	×
163	this.extraHeaders = fields.extraHeaders;	×
164	}
165	}
166	}
167	export interface CreateShieldInformationBarrierReportHeadersInput {
168	/**
169	* Extra headers that will be included in the HTTP request. */
170	readonly extraHeaders?:
171	\| undefined
172	\| {
173	readonly [key: string]: undefined \| string;
174	};
175	}
176	export class GetShieldInformationBarrierReportByIdHeaders {	138✔
177	/**
178	* Extra headers that will be included in the HTTP request. */
179	readonly extraHeaders?: {	×
180	readonly [key: string]: undefined \| string;
181	} = {};
182	constructor(
183	fields: Omit<GetShieldInformationBarrierReportByIdHeaders, 'extraHeaders'> &
184	Partial<
185	Pick<GetShieldInformationBarrierReportByIdHeaders, 'extraHeaders'>
186	>
187	) {
188	if (fields.extraHeaders) {	×
189	this.extraHeaders = fields.extraHeaders;	×
190	}
191	}
192	}
193	export interface GetShieldInformationBarrierReportByIdHeadersInput {
194	/**
195	* Extra headers that will be included in the HTTP request. */
196	readonly extraHeaders?:
197	\| undefined
198	\| {
199	readonly [key: string]: undefined \| string;
200	};
201	}
202	export class ShieldInformationBarrierReportsManager {	138✔
203	readonly auth?: Authentication;
204	readonly networkSession: NetworkSession = new NetworkSession({});	290✔
205	constructor(
206	fields: Omit<
207	ShieldInformationBarrierReportsManager,
208	\| 'networkSession'
209	\| 'getShieldInformationBarrierReports'
210	\| 'createShieldInformationBarrierReport'
211	\| 'getShieldInformationBarrierReportById'
212	> &
213	Partial<Pick<ShieldInformationBarrierReportsManager, 'networkSession'>>
214	) {
215	if (fields.auth) {	290✔
216	this.auth = fields.auth;	290✔
217	}
218	if (fields.networkSession) {	290✔
219	this.networkSession = fields.networkSession;	290✔
220	}
221	}
222	/**
223	* Lists shield information barrier reports.
224	* @param {GetShieldInformationBarrierReportsQueryParams} queryParams Query parameters of getShieldInformationBarrierReports method
225	* @param {GetShieldInformationBarrierReportsOptionalsInput} optionalsInput
226	* @returns {Promise<ShieldInformationBarrierReports>}
227	*/
228	async getShieldInformationBarrierReports(
229	queryParams: GetShieldInformationBarrierReportsQueryParams,	2✔
230	optionalsInput: GetShieldInformationBarrierReportsOptionalsInput = {}	2✔
231	): Promise<ShieldInformationBarrierReports> {
232	const optionals: GetShieldInformationBarrierReportsOptionals =
233	new GetShieldInformationBarrierReportsOptionals({	2✔
234	headers: optionalsInput.headers,
235	cancellationToken: optionalsInput.cancellationToken,
236	});
237	const headers: any = optionals.headers;	2✔
238	const cancellationToken: any = optionals.cancellationToken;	2✔
239	const queryParamsMap: {
240	readonly [key: string]: string;
241	} = prepareParams({	2✔
242	['shield_information_barrier_id']: toString(
243	queryParams.shieldInformationBarrierId
244	) as string,
245	['marker']: toString(queryParams.marker) as string,
246	['limit']: toString(queryParams.limit) as string,
247	});
248	const headersMap: {
249	readonly [key: string]: string;
250	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
251	const response: FetchResponse = (await fetch({	2✔
252	url: ''.concat(
253	this.networkSession.baseUrls.baseUrl,
254	'/2.0/shield_information_barrier_reports'
255	) as string,
256	method: 'GET',
257	params: queryParamsMap,
258	headers: headersMap,
259	responseFormat: 'json',
260	auth: this.auth,
261	networkSession: this.networkSession,
262	cancellationToken: cancellationToken,
263	} satisfies FetchOptions)) as FetchResponse;
264	return deserializeShieldInformationBarrierReports(response.data);	2✔
265	}
266	/**
267	* Creates a shield information barrier report for a given barrier.
268	* @param {ShieldInformationBarrierReference} requestBody Request body of createShieldInformationBarrierReport method
269	* @param {CreateShieldInformationBarrierReportOptionalsInput} optionalsInput
270	* @returns {Promise<ShieldInformationBarrierReport>}
271	*/
272	async createShieldInformationBarrierReport(
273	requestBody: ShieldInformationBarrierReference,	×
274	optionalsInput: CreateShieldInformationBarrierReportOptionalsInput = {}	×
275	): Promise<ShieldInformationBarrierReport> {
276	const optionals: CreateShieldInformationBarrierReportOptionals =
277	new CreateShieldInformationBarrierReportOptionals({	×
278	headers: optionalsInput.headers,
279	cancellationToken: optionalsInput.cancellationToken,
280	});
281	const headers: any = optionals.headers;	×
282	const cancellationToken: any = optionals.cancellationToken;	×
283	const headersMap: {
284	readonly [key: string]: string;
285	} = prepareParams({ ...{}, ...headers.extraHeaders });	×
NEW 286	const response: FetchResponse = (await fetch({	×
287	url: ''.concat(
288	this.networkSession.baseUrls.baseUrl,
289	'/2.0/shield_information_barrier_reports'
290	) as string,
291	method: 'POST',
292	headers: headersMap,
293	data: serializeShieldInformationBarrierReference(requestBody),
294	contentType: 'application/json',
295	responseFormat: 'json',
296	auth: this.auth,
297	networkSession: this.networkSession,
298	cancellationToken: cancellationToken,
299	} satisfies FetchOptions)) as FetchResponse;
UNCOV 300	return deserializeShieldInformationBarrierReport(response.data);	×
301	}
302	/**
303	* Retrieves a shield information barrier report by its ID.
304	* @param {string} shieldInformationBarrierReportId The ID of the shield information barrier Report.
305	Example: "3423"
306	* @param {GetShieldInformationBarrierReportByIdOptionalsInput} optionalsInput
307	* @returns {Promise<ShieldInformationBarrierReport>}
308	*/
309	async getShieldInformationBarrierReportById(
310	shieldInformationBarrierReportId: string,	×
311	optionalsInput: GetShieldInformationBarrierReportByIdOptionalsInput = {}	×
312	): Promise<ShieldInformationBarrierReport> {
313	const optionals: GetShieldInformationBarrierReportByIdOptionals =
314	new GetShieldInformationBarrierReportByIdOptionals({	×
315	headers: optionalsInput.headers,
316	cancellationToken: optionalsInput.cancellationToken,
317	});
318	const headers: any = optionals.headers;	×
319	const cancellationToken: any = optionals.cancellationToken;	×
320	const headersMap: {
321	readonly [key: string]: string;
322	} = prepareParams({ ...{}, ...headers.extraHeaders });	×
NEW 323	const response: FetchResponse = (await fetch({	×
324	url: ''.concat(
325	this.networkSession.baseUrls.baseUrl,
326	'/2.0/shield_information_barrier_reports/',
327	toString(shieldInformationBarrierReportId) as string
328	) as string,
329	method: 'GET',
330	headers: headersMap,
331	responseFormat: 'json',
332	auth: this.auth,
333	networkSession: this.networkSession,
334	cancellationToken: cancellationToken,
335	} satisfies FetchOptions)) as FetchResponse;
UNCOV 336	return deserializeShieldInformationBarrierReport(response.data);	×
337	}
338	}
339	export interface ShieldInformationBarrierReportsManagerInput {
340	readonly auth?: Authentication;
341	readonly networkSession?: NetworkSession;
342	}

box / box-typescript-sdk-gen / 10523193890

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