10040883711

Committed 22 Jul 2024 12:33PM UTC coverage: 41.915% (-0.01%) from 41.926%

Build # 10040883711

Build Type

Pull #260

github

Committed by

web-flow

Commit Message

Merge 5ce50cfe7 into fa8952a65

Pull Request Pull Request #260: feat: Support AI Agent API (box/box-codegen#531)

Run Details

3969 of 16256 branches covered (24.42%)

Branch coverage included in aggregate %.

204 of 374 new or added lines in 13 files covered. (54.55%)

1 existing line in 1 file now uncovered.

12840 of 23847 relevant lines covered (53.84%)

76.19 hits per line

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

72.34

/src/managers/ai.generated.ts

import { serializeAiResponse } from '../schemas/aiResponse.generated.js';
import { deserializeAiResponse } from '../schemas/aiResponse.generated.js';
import { serializeClientError } from '../schemas/clientError.generated.js';
import { deserializeClientError } from '../schemas/clientError.generated.js';
import { serializeAiAsk } from '../schemas/aiAsk.generated.js';
import { deserializeAiAsk } from '../schemas/aiAsk.generated.js';
import { serializeAiTextGen } from '../schemas/aiTextGen.generated.js';
import { deserializeAiTextGen } from '../schemas/aiTextGen.generated.js';
import { serializeAiAgentAskOrAiAgentTextGen } from '../schemas/aiAgentAskOrAiAgentTextGen.generated.js';
import { deserializeAiAgentAskOrAiAgentTextGen } from '../schemas/aiAgentAskOrAiAgentTextGen.generated.js';
import { AiResponse } from '../schemas/aiResponse.generated.js';
import { ClientError } from '../schemas/clientError.generated.js';
import { AiAsk } from '../schemas/aiAsk.generated.js';
import { AiTextGen } from '../schemas/aiTextGen.generated.js';
import { AiAgentAskOrAiAgentTextGen } from '../schemas/aiAgentAskOrAiAgentTextGen.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 { FetchOptions } from '../networking/fetch.js';
import { FetchResponse } from '../networking/fetch.js';
import { fetch } from '../networking/fetch.js';
import { SerializedData } from '../serialization/json.js';
import { sdToJson } from '../serialization/json.js';
import { BoxSdkError } from '../box/errors.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 CreateAiAskOptionals {
  readonly headers: CreateAiAskHeaders = new CreateAiAskHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<CreateAiAskOptionals, 'headers' | 'cancellationToken'> &
      Partial<Pick<CreateAiAskOptionals, 'headers' | 'cancellationToken'>>
  ) {
    if (fields.headers) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface CreateAiAskOptionalsInput {
  readonly headers?: CreateAiAskHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class CreateAiTextGenOptionals {
  readonly headers: CreateAiTextGenHeaders = new CreateAiTextGenHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<CreateAiTextGenOptionals, 'headers' | 'cancellationToken'> &
      Partial<Pick<CreateAiTextGenOptionals, 'headers' | 'cancellationToken'>>
  ) {
    if (fields.headers) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface CreateAiTextGenOptionalsInput {
  readonly headers?: CreateAiTextGenHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class GetAiAgentDefaultConfigOptionals {
  readonly headers: GetAiAgentDefaultConfigHeaders =
    new GetAiAgentDefaultConfigHeaders({});
  readonly cancellationToken?: CancellationToken = void 0;
  constructor(
    fields: Omit<
      GetAiAgentDefaultConfigOptionals,
      'headers' | 'cancellationToken'
    > &
      Partial<
        Pick<GetAiAgentDefaultConfigOptionals, 'headers' | 'cancellationToken'>
      >
  ) {
    if (fields.headers) {
      this.headers = fields.headers;
    }
    if (fields.cancellationToken) {
      this.cancellationToken = fields.cancellationToken;
    }
  }
}
export interface GetAiAgentDefaultConfigOptionalsInput {
  readonly headers?: GetAiAgentDefaultConfigHeaders;
  readonly cancellationToken?: undefined | CancellationToken;
}
export class CreateAiAskHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<CreateAiAskHeaders, 'extraHeaders'> &
      Partial<Pick<CreateAiAskHeaders, 'extraHeaders'>>
  ) {
    if (fields.extraHeaders) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface CreateAiAskHeadersInput {
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class CreateAiTextGenHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<CreateAiTextGenHeaders, 'extraHeaders'> &
      Partial<Pick<CreateAiTextGenHeaders, 'extraHeaders'>>
  ) {
    if (fields.extraHeaders) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface CreateAiTextGenHeadersInput {
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export type GetAiAgentDefaultConfigQueryParamsModeField = 'ask' | 'text_gen';
export interface GetAiAgentDefaultConfigQueryParams {
  readonly mode: GetAiAgentDefaultConfigQueryParamsModeField;
  readonly language?: string;
  readonly model?: string;
}
export class GetAiAgentDefaultConfigHeaders {
  readonly extraHeaders?: {
    readonly [key: string]: undefined | string;
  } = {};
  constructor(
    fields: Omit<GetAiAgentDefaultConfigHeaders, 'extraHeaders'> &
      Partial<Pick<GetAiAgentDefaultConfigHeaders, 'extraHeaders'>>
  ) {
    if (fields.extraHeaders) {
      this.extraHeaders = fields.extraHeaders;
    }
  }
}
export interface GetAiAgentDefaultConfigHeadersInput {
  readonly extraHeaders?:
    | undefined
    | {
        readonly [key: string]: undefined | string;
      };
}
export class AiManager {
  readonly auth?: Authentication;
  readonly networkSession: NetworkSession = new NetworkSession({});
  constructor(
    fields: Omit<
      AiManager,
      | 'networkSession'
      | 'createAiAsk'
      | 'createAiTextGen'
      | 'getAiAgentDefaultConfig'
    > &
      Partial<Pick<AiManager, 'networkSession'>>
  ) {
    if (fields.auth) {
      this.auth = fields.auth;
    }
    if (fields.networkSession) {
      this.networkSession = fields.networkSession;
    }
  }
  async createAiAsk(
    requestBody: AiAsk,
    optionalsInput: CreateAiAskOptionalsInput = {}
  ): Promise<AiResponse> {
    const optionals: CreateAiAskOptionals = new CreateAiAskOptionals({
      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(
      ''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/ai/ask') as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeAiAsk(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeAiResponse(response.data);
  }
  async createAiTextGen(
    requestBody: AiTextGen,
    optionalsInput: CreateAiTextGenOptionalsInput = {}
  ): Promise<AiResponse> {
    const optionals: CreateAiTextGenOptionals = new CreateAiTextGenOptionals({
      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(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/2.0/ai/text_gen'
      ) as string,
      {
        method: 'POST',
        headers: headersMap,
        data: serializeAiTextGen(requestBody),
        contentType: 'application/json',
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeAiResponse(response.data);
  }
  async getAiAgentDefaultConfig(
    queryParams: GetAiAgentDefaultConfigQueryParams,
    optionalsInput: GetAiAgentDefaultConfigOptionalsInput = {}
  ): Promise<AiAgentAskOrAiAgentTextGen> {
    const optionals: GetAiAgentDefaultConfigOptionals =
      new GetAiAgentDefaultConfigOptionals({
        headers: optionalsInput.headers,
        cancellationToken: optionalsInput.cancellationToken,
      });
    const headers: any = optionals.headers;
    const cancellationToken: any = optionals.cancellationToken;
    const queryParamsMap: {
      readonly [key: string]: string;
    } = prepareParams({
      ['mode']: toString(queryParams.mode) as string,
      ['language']: toString(queryParams.language) as string,
      ['model']: toString(queryParams.model) as string,
    });
    const headersMap: {
      readonly [key: string]: string;
    } = prepareParams({ ...{}, ...headers.extraHeaders });
    const response: FetchResponse = (await fetch(
      ''.concat(
        this.networkSession.baseUrls.baseUrl,
        '/2.0/ai_agent_default'
      ) as string,
      {
        method: 'GET',
        params: queryParamsMap,
        headers: headersMap,
        responseFormat: 'json',
        auth: this.auth,
        networkSession: this.networkSession,
        cancellationToken: cancellationToken,
      } satisfies FetchOptions
    )) as FetchResponse;
    return deserializeAiAgentAskOrAiAgentTextGen(response.data);
  }
}
export interface AiManagerInput {
  readonly auth?: Authentication;
  readonly networkSession?: NetworkSession;
}
export function serializeGetAiAgentDefaultConfigQueryParamsModeField(
  val: GetAiAgentDefaultConfigQueryParamsModeField
): SerializedData {
  return val;
}
export function deserializeGetAiAgentDefaultConfigQueryParamsModeField(
  val: SerializedData
): GetAiAgentDefaultConfigQueryParamsModeField {
  if (val == 'ask') {
    return val;
  }
  if (val == 'text_gen') {
    return val;
  }
  throw new BoxSdkError({
    message: "Can't deserialize GetAiAgentDefaultConfigQueryParamsModeField",
  });
}

1	import { serializeAiResponse } from '../schemas/aiResponse.generated.js';
2	import { deserializeAiResponse } from '../schemas/aiResponse.generated.js';	138✔
3	import { serializeClientError } from '../schemas/clientError.generated.js';
4	import { deserializeClientError } from '../schemas/clientError.generated.js';
5	import { serializeAiAsk } from '../schemas/aiAsk.generated.js';	138✔
6	import { deserializeAiAsk } from '../schemas/aiAsk.generated.js';
7	import { serializeAiTextGen } from '../schemas/aiTextGen.generated.js';	138✔
8	import { deserializeAiTextGen } from '../schemas/aiTextGen.generated.js';
9	import { serializeAiAgentAskOrAiAgentTextGen } from '../schemas/aiAgentAskOrAiAgentTextGen.generated.js';
10	import { deserializeAiAgentAskOrAiAgentTextGen } from '../schemas/aiAgentAskOrAiAgentTextGen.generated.js';	138✔
11	import { AiResponse } from '../schemas/aiResponse.generated.js';
12	import { ClientError } from '../schemas/clientError.generated.js';
13	import { AiAsk } from '../schemas/aiAsk.generated.js';
14	import { AiTextGen } from '../schemas/aiTextGen.generated.js';
15	import { AiAgentAskOrAiAgentTextGen } from '../schemas/aiAgentAskOrAiAgentTextGen.generated.js';
16	import { Authentication } from '../networking/auth.generated.js';
17	import { NetworkSession } from '../networking/network.generated.js';	138✔
18	import { prepareParams } from '../internal/utils.js';	138✔
19	import { toString } from '../internal/utils.js';	138✔
20	import { ByteStream } from '../internal/utils.js';
21	import { CancellationToken } from '../internal/utils.js';
22	import { FetchOptions } from '../networking/fetch.js';
23	import { FetchResponse } from '../networking/fetch.js';
24	import { fetch } from '../networking/fetch.js';	138✔
25	import { SerializedData } from '../serialization/json.js';
26	import { sdToJson } from '../serialization/json.js';
27	import { BoxSdkError } from '../box/errors.js';	138✔
28	import { sdIsEmpty } from '../serialization/json.js';
29	import { sdIsBoolean } from '../serialization/json.js';
30	import { sdIsNumber } from '../serialization/json.js';
31	import { sdIsString } from '../serialization/json.js';
32	import { sdIsList } from '../serialization/json.js';
33	import { sdIsMap } from '../serialization/json.js';
34	export class CreateAiAskOptionals {	138✔
35	readonly headers: CreateAiAskHeaders = new CreateAiAskHeaders({});	4✔
36	readonly cancellationToken?: CancellationToken = void 0;	4✔
37	constructor(
38	fields: Omit<CreateAiAskOptionals, 'headers' \| 'cancellationToken'> &
39	Partial<Pick<CreateAiAskOptionals, 'headers' \| 'cancellationToken'>>
40	) {
41	if (fields.headers) {	4!
42	this.headers = fields.headers;	×
43	}
44	if (fields.cancellationToken) {	4!
45	this.cancellationToken = fields.cancellationToken;	×
46	}
47	}
48	}
49	export interface CreateAiAskOptionalsInput {
50	readonly headers?: CreateAiAskHeaders;
51	readonly cancellationToken?: undefined \| CancellationToken;
52	}
53	export class CreateAiTextGenOptionals {	138✔
54	readonly headers: CreateAiTextGenHeaders = new CreateAiTextGenHeaders({});	2✔
55	readonly cancellationToken?: CancellationToken = void 0;	2✔
56	constructor(
57	fields: Omit<CreateAiTextGenOptionals, 'headers' \| 'cancellationToken'> &
58	Partial<Pick<CreateAiTextGenOptionals, 'headers' \| 'cancellationToken'>>
59	) {
60	if (fields.headers) {	2!
61	this.headers = fields.headers;	×
62	}
63	if (fields.cancellationToken) {	2!
64	this.cancellationToken = fields.cancellationToken;	×
65	}
66	}
67	}
68	export interface CreateAiTextGenOptionalsInput {
69	readonly headers?: CreateAiTextGenHeaders;
70	readonly cancellationToken?: undefined \| CancellationToken;
71	}
72	export class GetAiAgentDefaultConfigOptionals {	138✔
73	readonly headers: GetAiAgentDefaultConfigHeaders =	4✔
74	new GetAiAgentDefaultConfigHeaders({});
75	readonly cancellationToken?: CancellationToken = void 0;	4✔
76	constructor(
77	fields: Omit<
78	GetAiAgentDefaultConfigOptionals,
79	'headers' \| 'cancellationToken'
80	> &
81	Partial<
82	Pick<GetAiAgentDefaultConfigOptionals, 'headers' \| 'cancellationToken'>
83	>
84	) {
85	if (fields.headers) {	4!
NEW 86	this.headers = fields.headers;	×
87	}
88	if (fields.cancellationToken) {	4!
NEW 89	this.cancellationToken = fields.cancellationToken;	×
90	}
91	}
92	}
93	export interface GetAiAgentDefaultConfigOptionalsInput {
94	readonly headers?: GetAiAgentDefaultConfigHeaders;
95	readonly cancellationToken?: undefined \| CancellationToken;
96	}
97	export class CreateAiAskHeaders {	138✔
98	readonly extraHeaders?: {	4✔
99	readonly [key: string]: undefined \| string;
100	} = {};
101	constructor(
102	fields: Omit<CreateAiAskHeaders, 'extraHeaders'> &
103	Partial<Pick<CreateAiAskHeaders, 'extraHeaders'>>
104	) {
105	if (fields.extraHeaders) {	4!
106	this.extraHeaders = fields.extraHeaders;	×
107	}
108	}
109	}
110	export interface CreateAiAskHeadersInput {
111	readonly extraHeaders?:
112	\| undefined
113	\| {
114	readonly [key: string]: undefined \| string;
115	};
116	}
117	export class CreateAiTextGenHeaders {	138✔
118	readonly extraHeaders?: {	2✔
119	readonly [key: string]: undefined \| string;
120	} = {};
121	constructor(
122	fields: Omit<CreateAiTextGenHeaders, 'extraHeaders'> &
123	Partial<Pick<CreateAiTextGenHeaders, 'extraHeaders'>>
124	) {
125	if (fields.extraHeaders) {	2!
126	this.extraHeaders = fields.extraHeaders;	×
127	}
128	}
129	}
130	export interface CreateAiTextGenHeadersInput {
131	readonly extraHeaders?:
132	\| undefined
133	\| {
134	readonly [key: string]: undefined \| string;
135	};
136	}
137	export type GetAiAgentDefaultConfigQueryParamsModeField = 'ask' \| 'text_gen';
138	export interface GetAiAgentDefaultConfigQueryParams {
139	readonly mode: GetAiAgentDefaultConfigQueryParamsModeField;
140	readonly language?: string;
141	readonly model?: string;
142	}
143	export class GetAiAgentDefaultConfigHeaders {	138✔
144	readonly extraHeaders?: {	4✔
145	readonly [key: string]: undefined \| string;
146	} = {};
147	constructor(
148	fields: Omit<GetAiAgentDefaultConfigHeaders, 'extraHeaders'> &
149	Partial<Pick<GetAiAgentDefaultConfigHeaders, 'extraHeaders'>>
150	) {
151	if (fields.extraHeaders) {	4!
NEW 152	this.extraHeaders = fields.extraHeaders;	×
153	}
154	}
155	}
156	export interface GetAiAgentDefaultConfigHeadersInput {
157	readonly extraHeaders?:
158	\| undefined
159	\| {
160	readonly [key: string]: undefined \| string;
161	};
162	}
163	export class AiManager {	138✔
164	readonly auth?: Authentication;
165	readonly networkSession: NetworkSession = new NetworkSession({});	290✔
166	constructor(
167	fields: Omit<
168	AiManager,
169	\| 'networkSession'
170	\| 'createAiAsk'
171	\| 'createAiTextGen'
172	\| 'getAiAgentDefaultConfig'
173	> &
174	Partial<Pick<AiManager, 'networkSession'>>
175	) {
176	if (fields.auth) {	290✔
177	this.auth = fields.auth;	290✔
178	}
179	if (fields.networkSession) {	290✔
180	this.networkSession = fields.networkSession;	290✔
181	}
182	}
183	async createAiAsk(
184	requestBody: AiAsk,	4✔
185	optionalsInput: CreateAiAskOptionalsInput = {}	4✔
186	): Promise<AiResponse> {
187	const optionals: CreateAiAskOptionals = new CreateAiAskOptionals({	4✔
188	headers: optionalsInput.headers,
189	cancellationToken: optionalsInput.cancellationToken,
190	});
191	const headers: any = optionals.headers;	4✔
192	const cancellationToken: any = optionals.cancellationToken;	4✔
193	const headersMap: {
194	readonly [key: string]: string;
195	} = prepareParams({ ...{}, ...headers.extraHeaders });	4✔
196	const response: FetchResponse = (await fetch(	4✔
197	''.concat(this.networkSession.baseUrls.baseUrl, '/2.0/ai/ask') as string,
198	{
199	method: 'POST',
200	headers: headersMap,
201	data: serializeAiAsk(requestBody),
202	contentType: 'application/json',
203	responseFormat: 'json',
204	auth: this.auth,
205	networkSession: this.networkSession,
206	cancellationToken: cancellationToken,
207	} satisfies FetchOptions
208	)) as FetchResponse;
209	return deserializeAiResponse(response.data);	4✔
210	}
211	async createAiTextGen(
212	requestBody: AiTextGen,	2✔
213	optionalsInput: CreateAiTextGenOptionalsInput = {}	2✔
214	): Promise<AiResponse> {
215	const optionals: CreateAiTextGenOptionals = new CreateAiTextGenOptionals({	2✔
216	headers: optionalsInput.headers,
217	cancellationToken: optionalsInput.cancellationToken,
218	});
219	const headers: any = optionals.headers;	2✔
220	const cancellationToken: any = optionals.cancellationToken;	2✔
221	const headersMap: {
222	readonly [key: string]: string;
223	} = prepareParams({ ...{}, ...headers.extraHeaders });	2✔
224	const response: FetchResponse = (await fetch(	2✔
225	''.concat(
226	this.networkSession.baseUrls.baseUrl,
227	'/2.0/ai/text_gen'
228	) as string,
229	{
230	method: 'POST',
231	headers: headersMap,
232	data: serializeAiTextGen(requestBody),
233	contentType: 'application/json',
234	responseFormat: 'json',
235	auth: this.auth,
236	networkSession: this.networkSession,
237	cancellationToken: cancellationToken,
238	} satisfies FetchOptions
239	)) as FetchResponse;
240	return deserializeAiResponse(response.data);	2✔
241	}
242	async getAiAgentDefaultConfig(
243	queryParams: GetAiAgentDefaultConfigQueryParams,	4✔
244	optionalsInput: GetAiAgentDefaultConfigOptionalsInput = {}	4✔
245	): Promise<AiAgentAskOrAiAgentTextGen> {
246	const optionals: GetAiAgentDefaultConfigOptionals =
247	new GetAiAgentDefaultConfigOptionals({	4✔
248	headers: optionalsInput.headers,
249	cancellationToken: optionalsInput.cancellationToken,
250	});
251	const headers: any = optionals.headers;	4✔
252	const cancellationToken: any = optionals.cancellationToken;	4✔
253	const queryParamsMap: {
254	readonly [key: string]: string;
255	} = prepareParams({	4✔
256	['mode']: toString(queryParams.mode) as string,
257	['language']: toString(queryParams.language) as string,
258	['model']: toString(queryParams.model) as string,
259	});
260	const headersMap: {
261	readonly [key: string]: string;
262	} = prepareParams({ ...{}, ...headers.extraHeaders });	4✔
263	const response: FetchResponse = (await fetch(	4✔
264	''.concat(
265	this.networkSession.baseUrls.baseUrl,
266	'/2.0/ai_agent_default'
267	) as string,
268	{
269	method: 'GET',
270	params: queryParamsMap,
271	headers: headersMap,
272	responseFormat: 'json',
273	auth: this.auth,
274	networkSession: this.networkSession,
275	cancellationToken: cancellationToken,
276	} satisfies FetchOptions
277	)) as FetchResponse;
278	return deserializeAiAgentAskOrAiAgentTextGen(response.data);	4✔
279	}
280	}
281	export interface AiManagerInput {
282	readonly auth?: Authentication;
283	readonly networkSession?: NetworkSession;
284	}
285	export function serializeGetAiAgentDefaultConfigQueryParamsModeField(	138✔
286	val: GetAiAgentDefaultConfigQueryParamsModeField
287	): SerializedData {
NEW 288	return val;	×
289	}
290	export function deserializeGetAiAgentDefaultConfigQueryParamsModeField(	138✔
291	val: SerializedData
292	): GetAiAgentDefaultConfigQueryParamsModeField {
NEW 293	if (val == 'ask') {	×
NEW 294	return val;	×
295	}
NEW 296	if (val == 'text_gen') {	×
NEW 297	return val;	×
298	}
NEW 299	throw new BoxSdkError({	×
300	message: "Can't deserialize GetAiAgentDefaultConfigQueryParamsModeField",
301	});
302	}

box / box-typescript-sdk-gen / 10040883711

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