12870156465

Committed 20 Jan 2025 02:28PM UTC coverage: 42.419%. First build

Build # 12870156465

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Use extensible enums (box/box-codegen#639) (#487)

Run Details

3990 of 15999 branches covered (24.94%)

Branch coverage included in aggregate %.

0 of 408 new or added lines in 104 files covered. (0.0%)

14249 of 26998 relevant lines covered (52.78%)

93.02 hits per line

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

55.93

/src/managers/trashedItems.generated.ts

import { serializeItems } from '../schemas/items.generated.js';
import { deserializeItems } from '../schemas/items.generated.js';
import { serializeClientError } from '../schemas/clientError.generated.js';
import { deserializeClientError } from '../schemas/clientError.generated.js';
import { ResponseFormat } from '../networking/fetchOptions.generated.js';
import { Items } from '../schemas/items.generated.js';
import { ClientError } from '../schemas/clientError.generated.js';
import { BoxSdkError } from '../box/errors.js';
import { Authentication } from '../networking/auth.generated.js';
import { NetworkSession } from '../networking/network.generated.js';
import { FetchOptions } from '../networking/fetchOptions.generated.js';
import { FetchResponse } from '../networking/fetchResponse.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 { 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 type GetTrashedItemsQueryParamsDirectionField = 'ASC' | 'DESC' | string;
export type GetTrashedItemsQueryParamsSortField =
  | 'name'
  | 'date'
  | 'size'
  | string;
export interface GetTrashedItemsQueryParams {
  /**
   * A comma-separated list of attributes to include in the
   * response. This can be used to request fields that are
   * not normally returned in a standard response.
   *
   * Be aware that specifying this parameter will have the
   * effect that none of the standard fields are returned in
   * the response unless explicitly specified, instead only
   * fields for the mini representation are returned, additional
   * to the fields requested. */
  readonly fields?: readonly string[];
  /**
   * The maximum number of items to return per page. */
  readonly limit?: number;
  /**
   * The offset of the item at which to begin the response.
   *
   * Queries with offset parameter value
   * exceeding 10000 will be rejected
   * with a 400 response. */
  readonly offset?: number;
  /**
   * Specifies whether to use marker-based pagination instead of
   * offset-based pagination. Only one pagination method can
   * be used at a time.
   *
   * By setting this value to true, the API will return a `marker` field
   * that can be passed as a parameter to this endpoint to get the next
   * page of the response. */
  readonly usemarker?: boolean;
  /**
   * 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 direction to sort results in. This can be either in alphabetical ascending
   * (`ASC`) or descending (`DESC`) order. */
  readonly direction?: GetTrashedItemsQueryParamsDirectionField;
  /**
   * Defines the **second** attribute by which items
   * are sorted.
   *
   * Items are always sorted by their `type` first, with
   * folders listed before files, and files listed
   * before web links.
   *
   * This parameter is not supported when using marker-based pagination. */
  readonly sort?: GetTrashedItemsQueryParamsSortField;
}
export class GetTrashedItemsHeaders {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetTrashedItemsHeaders, 'extraHeaders'> &
      Partial<Pick<GetTrashedItemsHeaders, 'extraHeaders'>>,
  ) {
    if (fields.extraHeaders !== undefined) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetTrashedItemsHeadersInput {
  /**
   * Extra headers that will be included in the HTTP request. */
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class TrashedItemsManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields: Omit<TrashedItemsManager, 'networkSession' | 'getTrashedItems'> &
      Partial<Pick<TrashedItemsManager, 'networkSession'>>,
  ) {
    if (fields.auth !== undefined) {
      this.auth = fields.auth;
    }
    if (fields.networkSession !== undefined) {
      this.networkSession = fields.networkSession;
    }
  }
  /**
   * Retrieves the files and folders that have been moved
   * to the trash.
   *
   * Any attribute in the full files or folders objects can be passed
   * in with the `fields` parameter to retrieve those specific
   * attributes that are not returned by default.
   *
   * This endpoint defaults to use offset-based pagination, yet also supports
   * marker-based pagination using the `marker` parameter.
   * @param {GetTrashedItemsQueryParams} queryParams Query parameters of getTrashedItems method
   * @param {GetTrashedItemsHeadersInput} headersInput Headers of getTrashedItems method
   * @param {CancellationToken} cancellationToken Token used for request cancellation.
   * @returns {Promise<Items>}
   */
  async getTrashedItems(
    queryParams: GetTrashedItemsQueryParams = {} satisfies GetTrashedItemsQueryParams,
    headersInput: GetTrashedItemsHeadersInput = new GetTrashedItemsHeaders({}),
    cancellationToken?: CancellationToken,
  ): Promise<Items> {
    const headers: GetTrashedItemsHeaders = new GetTrashedItemsHeaders({
      extraHeaders: headersInput.extraHeaders,
    });
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['fields']: queryParams.fields
        ? queryParams.fields.map(toString).join(',')
        : undefined,
      ['limit']: toString(queryParams.limit) as string,
      ['offset']: toString(queryParams.offset) as string,
      ['usemarker']: toString(queryParams.usemarker) as string,
      ['marker']: toString(queryParams.marker) as string,
      ['direction']: toString(queryParams.direction) as string,
      ['sort']: toString(queryParams.sort) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse =
      await this.networkSession.networkClient.fetch(
        new FetchOptions({
          url: ''.concat(
            this.networkSession.baseUrls.baseUrl,
            '/2.0/folders/trash/items',
          ) as string,
          method: 'GET',
          params: queryParamsMap,
          headers: headersMap,
          responseFormat: 'json' as ResponseFormat,
          auth: this.auth,
          networkSession: this.networkSession,
          cancellationToken: cancellationToken,
        }),
      );
    return {
      ...deserializeItems(response.data!),
      rawData: response.data!,
    };
  }
}
export interface TrashedItemsManagerInput {
  readonly auth?: Authentication;
  readonly networkSession?: NetworkSession;
}
export function serializeGetTrashedItemsQueryParamsDirectionField(
  val: GetTrashedItemsQueryParamsDirectionField,
): SerializedData {
  return val;
}
export function deserializeGetTrashedItemsQueryParamsDirectionField(
  val: SerializedData,
): GetTrashedItemsQueryParamsDirectionField {
  if (val == 'ASC') {
    return val;
  }
  if (val == 'DESC') {
    return val;
  }
  if (sdIsString(val)) {
    return val;
  }
  throw new BoxSdkError({
    message: "Can't deserialize GetTrashedItemsQueryParamsDirectionField",
  });
}
export function serializeGetTrashedItemsQueryParamsSortField(
  val: GetTrashedItemsQueryParamsSortField,
): SerializedData {
  return val;
}
export function deserializeGetTrashedItemsQueryParamsSortField(
  val: SerializedData,
): GetTrashedItemsQueryParamsSortField {
  if (val == 'name') {
    return val;
  }
  if (val == 'date') {
    return val;
  }
  if (val == 'size') {
    return val;
  }
  if (sdIsString(val)) {
    return val;
  }
  throw new BoxSdkError({
    message: "Can't deserialize GetTrashedItemsQueryParamsSortField",
  });
}

1	import { serializeItems } from '../schemas/items.generated.js';
2	import { deserializeItems } from '../schemas/items.generated.js';	144✔
3	import { serializeClientError } from '../schemas/clientError.generated.js';
4	import { deserializeClientError } from '../schemas/clientError.generated.js';
5	import { ResponseFormat } from '../networking/fetchOptions.generated.js';
6	import { Items } from '../schemas/items.generated.js';
7	import { ClientError } from '../schemas/clientError.generated.js';
8	import { BoxSdkError } from '../box/errors.js';	144✔
9	import { Authentication } from '../networking/auth.generated.js';
10	import { NetworkSession } from '../networking/network.generated.js';	144✔
11	import { FetchOptions } from '../networking/fetchOptions.generated.js';	144✔
12	import { FetchResponse } from '../networking/fetchResponse.generated.js';
13	import { prepareParams } from '../internal/utils.js';	144✔
14	import { toString } from '../internal/utils.js';	144✔
15	import { ByteStream } from '../internal/utils.js';
16	import { CancellationToken } from '../internal/utils.js';
17	import { sdToJson } from '../serialization/json.js';
18	import { SerializedData } from '../serialization/json.js';
19	import { sdIsEmpty } from '../serialization/json.js';
20	import { sdIsBoolean } from '../serialization/json.js';
21	import { sdIsNumber } from '../serialization/json.js';
22	import { sdIsString } from '../serialization/json.js';	144✔
23	import { sdIsList } from '../serialization/json.js';
24	import { sdIsMap } from '../serialization/json.js';
25	export type GetTrashedItemsQueryParamsDirectionField = 'ASC' \| 'DESC' \| string;
26	export type GetTrashedItemsQueryParamsSortField =
27	\| 'name'
28	\| 'date'
29	\| 'size'
30	\| string;
31	export interface GetTrashedItemsQueryParams {
32	/**
33	* A comma-separated list of attributes to include in the
34	* response. This can be used to request fields that are
35	* not normally returned in a standard response.
36	*
37	* Be aware that specifying this parameter will have the
38	* effect that none of the standard fields are returned in
39	* the response unless explicitly specified, instead only
40	* fields for the mini representation are returned, additional
41	* to the fields requested. */
42	readonly fields?: readonly string[];
43	/**
44	* The maximum number of items to return per page. */
45	readonly limit?: number;
46	/**
47	* The offset of the item at which to begin the response.
48	*
49	* Queries with offset parameter value
50	* exceeding 10000 will be rejected
51	* with a 400 response. */
52	readonly offset?: number;
53	/**
54	* Specifies whether to use marker-based pagination instead of
55	* offset-based pagination. Only one pagination method can
56	* be used at a time.
57	*
58	* By setting this value to true, the API will return a `marker` field
59	* that can be passed as a parameter to this endpoint to get the next
60	* page of the response. */
61	readonly usemarker?: boolean;
62	/**
63	* Defines the position marker at which to begin returning results. This is
64	* used when paginating using marker-based pagination.
65	*
66	* This requires `usemarker` to be set to `true`. */
67	readonly marker?: string;
68	/**
69	* The direction to sort results in. This can be either in alphabetical ascending
70	* (`ASC`) or descending (`DESC`) order. */
71	readonly direction?: GetTrashedItemsQueryParamsDirectionField;
72	/**
73	* Defines the second attribute by which items
74	* are sorted.
75	*
76	* Items are always sorted by their `type` first, with
77	* folders listed before files, and files listed
78	* before web links.
79	*
80	* This parameter is not supported when using marker-based pagination. */
81	readonly sort?: GetTrashedItemsQueryParamsSortField;
82	}
83	export class GetTrashedItemsHeaders {	144✔
84	/**
85	* Extra headers that will be included in the HTTP request. */
86	readonly extraHeaders?: {	4✔
87	readonly [key: string]: undefined \| string;
88	} = {};
89	constructor(
90	fields: Omit<GetTrashedItemsHeaders, 'extraHeaders'> &
91	Partial<Pick<GetTrashedItemsHeaders, 'extraHeaders'>>,
92	) {
93	if (fields.extraHeaders !== undefined) {	4✔
94	this.extraHeaders = fields.extraHeaders;	2✔
95	}
96	}
97	}
98	export interface GetTrashedItemsHeadersInput {
99	/**
100	* Extra headers that will be included in the HTTP request. */
101	readonly extraHeaders?:
102	\| undefined
103	\| {
104	readonly [key: string]: undefined \| string;
105	};
106	}
107	export class TrashedItemsManager {	144✔
108	readonly auth?: Authentication;
109	readonly networkSession: NetworkSession = new NetworkSession({});	312✔
110	constructor(
111	fields: Omit<TrashedItemsManager, 'networkSession' \| 'getTrashedItems'> &
112	Partial<Pick<TrashedItemsManager, 'networkSession'>>,
113	) {
114	if (fields.auth !== undefined) {	312✔
115	this.auth = fields.auth;	312✔
116	}
117	if (fields.networkSession !== undefined) {	312✔
118	this.networkSession = fields.networkSession;	312✔
119	}
120	}
121	/**
122	* Retrieves the files and folders that have been moved
123	* to the trash.
124	*
125	* Any attribute in the full files or folders objects can be passed
126	* in with the `fields` parameter to retrieve those specific
127	* attributes that are not returned by default.
128	*
129	* This endpoint defaults to use offset-based pagination, yet also supports
130	* marker-based pagination using the `marker` parameter.
131	* @param {GetTrashedItemsQueryParams} queryParams Query parameters of getTrashedItems method
132	* @param {GetTrashedItemsHeadersInput} headersInput Headers of getTrashedItems method
133	* @param {CancellationToken} cancellationToken Token used for request cancellation.
134	* @returns {Promise<Items>}
135	*/
136	async getTrashedItems(
137	queryParams: GetTrashedItemsQueryParams = {} satisfies GetTrashedItemsQueryParams,	2✔
138	headersInput: GetTrashedItemsHeadersInput = new GetTrashedItemsHeaders({}),	2✔
139	cancellationToken?: CancellationToken,
140	): Promise<Items> {
141	const headers: GetTrashedItemsHeaders = new GetTrashedItemsHeaders({	2✔
142	extraHeaders: headersInput.extraHeaders,
143	});
144	const queryParamsMap: {
145	readonly [key: string]: string;
146	} = prepareParams({	2✔
147	['fields']: queryParams.fields	2!
148	? queryParams.fields.map(toString).join(',')
149	: undefined,
150	['limit']: toString(queryParams.limit) as string,
151	['offset']: toString(queryParams.offset) as string,
152	['usemarker']: toString(queryParams.usemarker) as string,
153	['marker']: toString(queryParams.marker) as string,
154	['direction']: toString(queryParams.direction) as string,
155	['sort']: toString(queryParams.sort) as string,
156	});
157	const headersMap: {
158	readonly [key: string]: string;
159	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
160	const response: FetchResponse =
161	await this.networkSession.networkClient.fetch(	2✔
162	new FetchOptions({
163	url: ''.concat(
164	this.networkSession.baseUrls.baseUrl,
165	'/2.0/folders/trash/items',
166	) as string,
167	method: 'GET',
168	params: queryParamsMap,
169	headers: headersMap,
170	responseFormat: 'json' as ResponseFormat,
171	auth: this.auth,
172	networkSession: this.networkSession,
173	cancellationToken: cancellationToken,
174	}),
175	);
176	return {	2✔
177	...deserializeItems(response.data!),
178	rawData: response.data!,
179	};
180	}
181	}
182	export interface TrashedItemsManagerInput {
183	readonly auth?: Authentication;
184	readonly networkSession?: NetworkSession;
185	}
186	export function serializeGetTrashedItemsQueryParamsDirectionField(	144✔
187	val: GetTrashedItemsQueryParamsDirectionField,
188	): SerializedData {
189	return val;	×
190	}
191	export function deserializeGetTrashedItemsQueryParamsDirectionField(	144✔
192	val: SerializedData,
193	): GetTrashedItemsQueryParamsDirectionField {
194	if (val == 'ASC') {	×
195	return val;	×
196	}
197	if (val == 'DESC') {	×
198	return val;	×
199	}
NEW 200	if (sdIsString(val)) {	×
NEW 201	return val;	×
202	}
203	throw new BoxSdkError({	×
204	message: "Can't deserialize GetTrashedItemsQueryParamsDirectionField",
205	});
206	}
207	export function serializeGetTrashedItemsQueryParamsSortField(	144✔
208	val: GetTrashedItemsQueryParamsSortField,
209	): SerializedData {
210	return val;	×
211	}
212	export function deserializeGetTrashedItemsQueryParamsSortField(	144✔
213	val: SerializedData,
214	): GetTrashedItemsQueryParamsSortField {
215	if (val == 'name') {	×
216	return val;	×
217	}
218	if (val == 'date') {	×
219	return val;	×
220	}
221	if (val == 'size') {	×
222	return val;	×
223	}
NEW 224	if (sdIsString(val)) {	×
NEW 225	return val;	×
226	}
227	throw new BoxSdkError({	×
228	message: "Can't deserialize GetTrashedItemsQueryParamsSortField",
229	});
230	}

box / box-typescript-sdk-gen / 12870156465

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